(svn r12980) -Fix: MorphOS threading support. Patch by Fabien Coeurjoly.

1 files changed, 272 insertions, 0 deletions

diff --git a/src/thread_morphos.cpp b/src/thread_morphos.cpp
new file mode 100644
index 000000000..6cd9e1498
--- /dev/null
+++ b/src/thread_morphos.cpp
@@ -0,0 +1,272 @@
+/* $Id$ */
+
+/** @file thread_morphos.cpp MorphOS implementation of Threads. */
+
+#include "stdafx.h"
+#include "thread.h"
+#include "debug.h"
+#include "core/alloc_func.hpp"
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <exec/types.h>
+#include <exec/rawfmt.h>
+#include <dos/dostags.h>
+
+#include <proto/dos.h>
+#include <proto/exec.h>
+
+/**
+ *  avoid name clashes with MorphOS API functions
+ */
+#undef Exit
+#undef Wait
+
+
+/**
+ *  NOTE: this code heavily depends on latest libnix updates. So make
+ *        sure you link with new stuff which supports semaphore locking of
+ *        the IO resources, else it will just go foobar.
+ */
+
+
+struct OTTDThreadStartupMessage {
+	struct Message msg;  ///< standard exec.library message (MUST be the first thing in the message struct!)
+	OTTDThreadFunc func; ///< function the thread will execute
+	void *arg;           ///< functions arguments for the thread function
+	void *ret;           ///< return value of the thread function
+};
+
+
+/**
+ *  Default OpenTTD STDIO/ERR debug output is not very useful for this, so we
+ *  utilize serial/ramdebug instead.
+ */
+#ifndef NO_DEBUG_MESSAGES
+void KPutStr(CONST_STRPTR format)
+{
+	RawDoFmt(format, NULL, (void (*)())RAWFMTFUNC_SERIAL, NULL);
+}
+#else
+#define KPutStr(x)
+#endif
+
+
+/**
+ * MorphOS version for ThreadObject.
+ */
+class ThreadObject_MorphOS : public ThreadObject {
+private:
+	APTR m_thr;                  ///< System thread identifier.
+	struct MsgPort *m_replyport;
+	struct OTTDThreadStartupMessage m_msg;
+
+public:
+	/**
+	 * Create a sub process and start it, calling proc(param).
+	 */
+	ThreadObject_MorphOS(OTTDThreadFunc proc, void *param) : m_thr(0)
+	{
+		struct Task *parent;
+
+		KPutStr("[OpenTTD] Create thread...\n");
+
+		parent = FindTask(NULL);
+
+		/* Make sure main thread runs with sane priority */
+		SetTaskPri(parent, 0);
+
+		/* Things we'll pass down to the child by utilizing NP_StartupMsg */
+		m_msg.func = proc;
+		m_msg.arg  = param;
+		m_msg.ret  = NULL;
+
+		m_replyport = CreateMsgPort();
+
+		if (m_replyport != NULL) {
+			struct Process *child;
+
+			m_msg.msg.mn_Node.ln_Type = NT_MESSAGE;
+			m_msg.msg.mn_ReplyPort    = m_replyport;
+			m_msg.msg.mn_Length       = sizeof(struct OTTDThreadStartupMessage);
+
+			child = CreateNewProcTags(
+				NP_CodeType,     CODETYPE_PPC,
+				NP_Entry,        ThreadObject_MorphOS::Proxy,
+				NP_StartupMsg,   (IPTR)&m_msg,
+				NP_Priority,     5UL,
+				NP_Name,         (IPTR)"OpenTTD Thread",
+				NP_PPCStackSize, 131072UL,
+				TAG_DONE);
+
+			m_thr = (APTR) child;
+
+			if (child != NULL) {
+				KPutStr("[OpenTTD] Child process launched.\n");
+			} else {
+				KPutStr("[OpenTTD] Couldn't create child process. (constructors never fail, yeah!)\n");
+				DeleteMsgPort(m_replyport);
+			}
+		}
+	}
+
+	/**
+	 * Create a thread and attach current thread to it.
+	 */
+	ThreadObject_MorphOS() : m_thr(0)
+	{
+		m_thr = FindTask(NULL);
+	}
+
+	/* virtual */ ~ThreadObject_MorphOS()
+	{
+	}
+
+	/* virtual */ bool IsRunning()
+	{
+		return m_thr != 0;
+	}
+
+	/* virtual */ bool WaitForStop()
+	{
+		/* You can't wait on yourself */
+		assert(!IsCurrent());
+		/* If the thread is not running, waiting is over */
+		if (!IsRunning()) return true;
+
+		WaitPort(m_replyport);
+
+		GetMsg(m_replyport);
+		DeleteMsgPort(m_replyport);
+
+		return true;
+	}
+
+	/* virtual */ bool Exit()
+	{
+		struct OTTDThreadStartupMessage *msg;
+
+		/* You can only exit yourself */
+		assert(IsCurrent());
+		/* If the thread is not running, we are already closed */
+		if (!IsRunning()) return false;
+
+		KPutStr("[Child] Aborting...\n");
+
+		if (NewGetTaskAttrs(NULL, &msg, sizeof(struct OTTDThreadStartupMessage *), TASKINFOTYPE_STARTUPMSG, TAG_DONE) && msg != NULL) {
+			/* For now we terminate by throwing an error, gives much cleaner cleanup */
+			throw 0;
+		}
+
+		return true;
+	}
+
+	/* virtual */ void *Join()
+	{
+		struct OTTDThreadStartupMessage *reply;
+		void *ret;
+
+		/* You cannot join yourself */
+		assert(!IsCurrent());
+
+		KPutStr("[OpenTTD] Join threads...\n");
+		KPutStr("[OpenTTD] Wait for child to quit...\n");
+		WaitPort(m_replyport);
+
+		reply = (struct OTTDThreadStartupMessage *)GetMsg(m_replyport);
+		ret   = reply->ret;
+
+		DeleteMsgPort(m_replyport);
+		m_thr = 0;
+
+		return ret;
+	}
+
+	/* virtual */ bool IsCurrent()
+	{
+		return FindTask(NULL) == m_thr;
+	}
+
+	/* virtual */ uint GetId()
+	{
+		return (uint)m_thr;
+	}
+
+private:
+	/**
+	 * On thread creation, this function is called, which calls the real startup
+	 *  function. This to get back into the correct instance again.
+	 */
+	static void Proxy(void)
+	{
+		struct Task *child = FindTask(NULL);
+		struct OTTDThreadStartupMessage *msg;
+
+		/* Make sure, we don't block the parent. */
+		SetTaskPri(child, -5);
+
+		KPutStr("[Child] Progressing...\n");
+
+		if (NewGetTaskAttrs(NULL, &msg, sizeof(struct OTTDThreadStartupMessage *), TASKINFOTYPE_STARTUPMSG, TAG_DONE) && msg != NULL) {
+			try {
+				msg->ret = msg->func(msg->arg);
+			} catch(...) {
+				KPutStr("[Child] Returned to main()\n");
+			}
+		}
+
+		/*  Quit the child, exec.library will reply the startup msg internally. */
+		KPutStr("[Child] Done.\n");
+	}
+};
+
+/* static */ ThreadObject *ThreadObject::New(OTTDThreadFunc proc, void *param)
+{
+	return new ThreadObject_MorphOS(proc, param);
+}
+
+/* static */ ThreadObject *ThreadObject::AttachCurrent()
+{
+	return new ThreadObject_MorphOS();
+}
+
+/* static */ uint ThreadObject::CurrentId()
+{
+	return (uint) FindTask(NULL);
+}
+
+
+/**
+ * MorphOS version of ThreadSemaphore.
+ */
+class ThreadSemaphore_MorphOS : public ThreadSemaphore {
+private:
+	struct SignalSemaphore m_sem;
+
+public:
+	ThreadSemaphore_MorphOS()
+	{
+		InitSemaphore(&m_sem);
+	}
+
+	/* virtual */ ~ThreadSemaphore_MorphOS()
+	{
+
+	}
+
+	/* virtual */ void Set()
+	{
+		// Check if semaphore count is really important there.
+		ReleaseSemaphore(&m_sem);
+	}
+
+	/* virtual */ void Wait()
+	{
+		ObtainSemaphore(&m_sem);
+	}
+};
+
+/* static */ ThreadSemaphore *ThreadSemaphore::New()
+{
+	return new ThreadSemaphore_MorphOS();
+}