1 /* $Id$ */

     2 

     3 /** @file thread_morphos.cpp MorphOS implementation of Threads. */

     4 

     5 #include "stdafx.h"

     6 #include "thread.h"

     7 #include "debug.h"

     8 #include "core/alloc_func.hpp"

     9 #include <stdlib.h>

    10 #include <unistd.h>

    11 

    12 #include <exec/types.h>

    13 #include <exec/rawfmt.h>

    14 #include <dos/dostags.h>

    15 

    16 #include <proto/dos.h>

    17 #include <proto/exec.h>

    18 

    19 /**

    20  *  avoid name clashes with MorphOS API functions

    21  */

    22 #undef Exit

    23 #undef Wait

    24 

    25 

    26 /**

    27  *  NOTE: this code heavily depends on latest libnix updates. So make

    28  *        sure you link with new stuff which supports semaphore locking of

    29  *        the IO resources, else it will just go foobar.

    30  */

    31 

    32 

    33 struct OTTDThreadStartupMessage {

    34 	struct Message msg;  ///< standard exec.library message (MUST be the first thing in the message struct!)

    35 	OTTDThreadFunc func; ///< function the thread will execute

    36 	void *arg;           ///< functions arguments for the thread function

    37 	void *ret;           ///< return value of the thread function

    38 };

    39 

    40 

    41 /**

    42  *  Default OpenTTD STDIO/ERR debug output is not very useful for this, so we

    43  *  utilize serial/ramdebug instead.

    44  */

    45 #ifndef NO_DEBUG_MESSAGES

    46 void KPutStr(CONST_STRPTR format)

    47 {

    48 	RawDoFmt(format, NULL, (void (*)())RAWFMTFUNC_SERIAL, NULL);

    49 }

    50 #else

    51 #define KPutStr(x)

    52 #endif

    53 

    54 

    55 /**

    56  * MorphOS version for ThreadObject.

    57  */

    58 class ThreadObject_MorphOS : public ThreadObject {

    59 private:

    60 	APTR m_thr;                  ///< System thread identifier.

    61 	struct MsgPort *m_replyport;

    62 	struct OTTDThreadStartupMessage m_msg;

    63 

    64 public:

    65 	/**

    66 	 * Create a sub process and start it, calling proc(param).

    67 	 */

    68 	ThreadObject_MorphOS(OTTDThreadFunc proc, void *param) : m_thr(0)

    69 	{

    70 		struct Task *parent;

    71 

    72 		KPutStr("[OpenTTD] Create thread...\n");

    73 

    74 		parent = FindTask(NULL);

    75 

    76 		/* Make sure main thread runs with sane priority */

    77 		SetTaskPri(parent, 0);

    78 

    79 		/* Things we'll pass down to the child by utilizing NP_StartupMsg */

    80 		m_msg.func = proc;

    81 		m_msg.arg  = param;

    82 		m_msg.ret  = NULL;

    83 

    84 		m_replyport = CreateMsgPort();

    85 

    86 		if (m_replyport != NULL) {

    87 			struct Process *child;

    88 

    89 			m_msg.msg.mn_Node.ln_Type = NT_MESSAGE;

    90 			m_msg.msg.mn_ReplyPort    = m_replyport;

    91 			m_msg.msg.mn_Length       = sizeof(struct OTTDThreadStartupMessage);

    92 

    93 			child = CreateNewProcTags(

    94 				NP_CodeType,     CODETYPE_PPC,

    95 				NP_Entry,        ThreadObject_MorphOS::Proxy,

    96 				NP_StartupMsg,   (IPTR)&m_msg,

    97 				NP_Priority,     5UL,

    98 				NP_Name,         (IPTR)"OpenTTD Thread",

    99 				NP_PPCStackSize, 131072UL,

   100 				TAG_DONE);

   101 

   102 			m_thr = (APTR) child;

   103 

   104 			if (child != NULL) {

   105 				KPutStr("[OpenTTD] Child process launched.\n");

   106 			} else {

   107 				KPutStr("[OpenTTD] Couldn't create child process. (constructors never fail, yeah!)\n");

   108 				DeleteMsgPort(m_replyport);

   109 			}

   110 		}

   111 	}

   112 

   113 	/**

   114 	 * Create a thread and attach current thread to it.

   115 	 */

   116 	ThreadObject_MorphOS() : m_thr(0)

   117 	{

   118 		m_thr = FindTask(NULL);

   119 	}

   120 

   121 	/* virtual */ ~ThreadObject_MorphOS()

   122 	{

   123 	}

   124 

   125 	/* virtual */ bool IsRunning()

   126 	{

   127 		return m_thr != 0;

   128 	}

   129 

   130 	/* virtual */ bool WaitForStop()

   131 	{

   132 		/* You can't wait on yourself */

   133 		assert(!IsCurrent());

   134 		/* If the thread is not running, waiting is over */

   135 		if (!IsRunning()) return true;

   136 

   137 		WaitPort(m_replyport);

   138 

   139 		GetMsg(m_replyport);

   140 		DeleteMsgPort(m_replyport);

   141 

   142 		return true;

   143 	}

   144 

   145 	/* virtual */ bool Exit()

   146 	{

   147 		struct OTTDThreadStartupMessage *msg;

   148 

   149 		/* You can only exit yourself */

   150 		assert(IsCurrent());

   151 		/* If the thread is not running, we are already closed */

   152 		if (!IsRunning()) return false;

   153 

   154 		KPutStr("[Child] Aborting...\n");

   155 

   156 		if (NewGetTaskAttrs(NULL, &msg, sizeof(struct OTTDThreadStartupMessage *), TASKINFOTYPE_STARTUPMSG, TAG_DONE) && msg != NULL) {

   157 			/* For now we terminate by throwing an error, gives much cleaner cleanup */

   158 			throw 0;

   159 		}

   160 

   161 		return true;

   162 	}

   163 

   164 	/* virtual */ void *Join()

   165 	{

   166 		struct OTTDThreadStartupMessage *reply;

   167 		void *ret;

   168 

   169 		/* You cannot join yourself */

   170 		assert(!IsCurrent());

   171 

   172 		KPutStr("[OpenTTD] Join threads...\n");

   173 		KPutStr("[OpenTTD] Wait for child to quit...\n");

   174 		WaitPort(m_replyport);

   175 

   176 		reply = (struct OTTDThreadStartupMessage *)GetMsg(m_replyport);

   177 		ret   = reply->ret;

   178 

   179 		DeleteMsgPort(m_replyport);

   180 		m_thr = 0;

   181 

   182 		return ret;

   183 	}

   184 

   185 	/* virtual */ bool IsCurrent()

   186 	{

   187 		return FindTask(NULL) == m_thr;

   188 	}

   189 

   190 	/* virtual */ uint GetId()

   191 	{

   192 		return (uint)m_thr;

   193 	}

   194 

   195 private:

   196 	/**

   197 	 * On thread creation, this function is called, which calls the real startup

   198 	 *  function. This to get back into the correct instance again.

   199 	 */

   200 	static void Proxy(void)

   201 	{

   202 		struct Task *child = FindTask(NULL);

   203 		struct OTTDThreadStartupMessage *msg;

   204 

   205 		/* Make sure, we don't block the parent. */

   206 		SetTaskPri(child, -5);

   207 

   208 		KPutStr("[Child] Progressing...\n");

   209 

   210 		if (NewGetTaskAttrs(NULL, &msg, sizeof(struct OTTDThreadStartupMessage *), TASKINFOTYPE_STARTUPMSG, TAG_DONE) && msg != NULL) {

   211 			try {

   212 				msg->ret = msg->func(msg->arg);

   213 			} catch(...) {

   214 				KPutStr("[Child] Returned to main()\n");

   215 			}

   216 		}

   217 

   218 		/*  Quit the child, exec.library will reply the startup msg internally. */

   219 		KPutStr("[Child] Done.\n");

   220 	}

   221 };

   222 

   223 /* static */ ThreadObject *ThreadObject::New(OTTDThreadFunc proc, void *param)

   224 {

   225 	return new ThreadObject_MorphOS(proc, param);

   226 }

   227 

   228 /* static */ ThreadObject *ThreadObject::AttachCurrent()

   229 {

   230 	return new ThreadObject_MorphOS();

   231 }

   232 

   233 /* static */ uint ThreadObject::CurrentId()

   234 {

   235 	return (uint) FindTask(NULL);

   236 }

   237 

   238 

   239 /**

   240  * MorphOS version of ThreadSemaphore.

   241  */

   242 class ThreadSemaphore_MorphOS : public ThreadSemaphore {

   243 private:

   244 	struct SignalSemaphore m_sem;

   245 

   246 public:

   247 	ThreadSemaphore_MorphOS()

   248 	{

   249 		InitSemaphore(&m_sem);

   250 	}

   251 

   252 	/* virtual */ ~ThreadSemaphore_MorphOS()

   253 	{

   254 

   255 	}

   256 

   257 	/* virtual */ void Set()

   258 	{

   259 		// Check if semaphore count is really important there.

   260 		ReleaseSemaphore(&m_sem);

   261 	}

   262 

   263 	/* virtual */ void Wait()

   264 	{

   265 		ObtainSemaphore(&m_sem);

   266 	}

   267 };

   268 

   269 /* static */ ThreadSemaphore *ThreadSemaphore::New()

   270 {

   271 	return new ThreadSemaphore_MorphOS();

   272 }