summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorrubidium <rubidium@openttd.org>2008-05-06 22:50:55 +0000
committerrubidium <rubidium@openttd.org>2008-05-06 22:50:55 +0000
commit3b9e4f6d178374b1e3c5cca1f2a60139d258b18e (patch)
tree57d2f3577d89480529373b027c9201eec378a367 /src
parenteaaf217a964693fdc4dff4ac303fd6ff797b1cae (diff)
downloadopenttd-3b9e4f6d178374b1e3c5cca1f2a60139d258b18e.tar.xz
(svn r12980) -Fix: MorphOS threading support. Patch by Fabien Coeurjoly.
Diffstat (limited to 'src')
-rw-r--r--src/thread_morphos.cpp272
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();
+}