summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/fiber.hpp53
-rw-r--r--src/fiber_thread.cpp153
-rw-r--r--src/fiber_win32.cpp206
-rw-r--r--src/genworld.cpp10
-rw-r--r--src/genworld.h17
-rw-r--r--src/saveload.cpp10
-rw-r--r--src/thread.cpp313
-rw-r--r--src/thread.h93
-rw-r--r--src/thread_none.cpp42
-rw-r--r--src/thread_os2.cpp80
-rw-r--r--src/thread_pthread.cpp199
-rw-r--r--src/thread_win32.cpp188
12 files changed, 1022 insertions, 342 deletions
diff --git a/src/fiber.hpp b/src/fiber.hpp
new file mode 100644
index 000000000..3ea776d5c
--- /dev/null
+++ b/src/fiber.hpp
@@ -0,0 +1,53 @@
+/* $Id$ */
+
+/** @file fiber.hpp */
+
+#ifndef FIBER_HPP
+#define FIBER_HPP
+
+typedef void (CDECL *FiberFunc)(void *);
+
+class Fiber {
+public:
+ /**
+ * Switch to this fiber.
+ */
+ virtual void SwitchToFiber() = 0;
+
+ /**
+ * Exit a fiber.
+ */
+ virtual void Exit() = 0;
+
+ /**
+ * Check if a fiber is running.
+ */
+ virtual bool IsRunning() = 0;
+
+ /**
+ * Get the 'param' data of the Fiber.
+ */
+ virtual void *GetFiberData() = 0;
+
+ /**
+ * Virtual Destructor to mute warnings.
+ */
+ virtual ~Fiber() {};
+
+ /**
+ * Create a new fiber, calling proc(param) when running.
+ */
+ static Fiber *New(FiberFunc proc, void *param);
+
+ /**
+ * Attach a current thread to a new fiber.
+ */
+ static Fiber *AttachCurrent(void *param);
+
+ /**
+ * Get the 'param' data of the current active Fiber.
+ */
+ static void *GetCurrentFiberData();
+};
+
+#endif /* FIBER_HPP */
diff --git a/src/fiber_thread.cpp b/src/fiber_thread.cpp
new file mode 100644
index 000000000..6d311290c
--- /dev/null
+++ b/src/fiber_thread.cpp
@@ -0,0 +1,153 @@
+/* $Id$ */
+
+/** @file fiber_thread.cpp ThreadObject implementation of Fiber. */
+
+#include "stdafx.h"
+#include "fiber.hpp"
+#include "thread.h"
+#include <stdlib.h>
+
+class Fiber_Thread : public Fiber {
+private:
+ ThreadObject *m_thread;
+ FiberFunc m_proc;
+ void *m_param;
+ bool m_attached;
+ ThreadSemaphore *m_sem;
+ bool m_kill;
+
+ static Fiber_Thread *s_current;
+ static Fiber_Thread *s_main;
+
+public:
+ /**
+ * Create a ThreadObject fiber and start it, calling proc(param).
+ */
+ Fiber_Thread(FiberFunc proc, void *param) :
+ m_thread(NULL),
+ m_proc(proc),
+ m_param(param),
+ m_attached(false),
+ m_kill(false)
+ {
+ this->m_sem = ThreadSemaphore::New();
+ /* Create a thread and start stFiberProc */
+ this->m_thread = ThreadObject::New(&stFiberProc, this);
+ }
+
+ /**
+ * Create a ThreadObject fiber and attach current thread to it.
+ */
+ Fiber_Thread(void *param) :
+ m_thread(NULL),
+ m_proc(NULL),
+ m_param(param),
+ m_attached(true),
+ m_kill(false)
+ {
+ this->m_sem = ThreadSemaphore::New();
+ /* Attach the current thread to this Fiber */
+ this->m_thread = ThreadObject::AttachCurrent();
+ /* We are the current thread */
+ if (s_current == NULL) s_current = this;
+ if (s_main == NULL) s_main = this;
+ }
+
+ ~Fiber_Thread()
+ {
+ /* Remove the thread if needed */
+ if (this->m_thread != NULL) {
+ assert(this->m_attached || !this->m_thread->IsRunning());
+ delete this->m_thread;
+ }
+ /* Remove the semaphore */
+ delete this->m_sem;
+ }
+
+ /* virtual */ void SwitchToFiber()
+ {
+ /* You can't switch to yourself */
+ assert(s_current != this);
+ Fiber_Thread *cur = s_current;
+
+ /* Continue the execution of 'this' Fiber */
+ this->m_sem->Set();
+ /* Hold the execution of the current Fiber */
+ cur->m_sem->Wait();
+ if (this->m_kill) {
+ /* If the thread we switched too was killed, join it so it can finish quiting */
+ this->m_thread->Join();
+ }
+ /* If we continue, we are the current thread */
+ s_current = cur;
+ }
+
+ /* virtual */ void Exit()
+ {
+ /* Kill off our thread */
+ this->m_kill = true;
+ this->m_thread->Exit();
+ }
+
+ /* virtual */ bool IsRunning()
+ {
+ if (this->m_thread == NULL) return false;
+ return this->m_thread->IsRunning();
+ }
+
+ /* virtual */ void *GetFiberData()
+ {
+ return this->m_param;
+ }
+
+ static Fiber_Thread *GetCurrentFiber()
+ {
+ return s_current;
+ }
+
+private:
+ /**
+ * First function which is called within the fiber.
+ */
+ static void * CDECL stFiberProc(void *fiber)
+ {
+ Fiber_Thread *cur = (Fiber_Thread *)fiber;
+ /* Now suspend the thread until we get SwitchToFiber() for the first time */
+ cur->m_sem->Wait();
+ /* If we continue, we are the current thread */
+ s_current = cur;
+
+ try {
+ cur->m_proc(cur->m_param);
+ } catch (...) {
+ /* Unlock the main thread */
+ s_main->m_sem->Set();
+ throw;
+ }
+
+ return NULL;
+ }
+};
+
+/* Initialize the static member of Fiber_Thread */
+/* static */ Fiber_Thread *Fiber_Thread::s_current = NULL;
+/* static */ Fiber_Thread *Fiber_Thread::s_main = NULL;
+
+#ifndef WIN32
+
+/* static */ Fiber *Fiber::New(FiberFunc proc, void *param)
+{
+ return new Fiber_Thread(proc, param);
+}
+
+/* static */ Fiber *Fiber::AttachCurrent(void *param)
+{
+ return new Fiber_Thread(param);
+}
+
+/* static */ void *Fiber::GetCurrentFiberData()
+{
+ return Fiber_Thread::GetCurrentFiber()->GetFiberData();
+}
+
+#endif /* WIN32 */
diff --git a/src/fiber_win32.cpp b/src/fiber_win32.cpp
new file mode 100644
index 000000000..61718188c
--- /dev/null
+++ b/src/fiber_win32.cpp
@@ -0,0 +1,206 @@
+/* $Id$ */
+
+/** @file fiber_win32.cpp Win32 implementation of Fiber. */
+
+#include "stdafx.h"
+#include "fiber.hpp"
+#include <stdlib.h>
+#include <windows.h>
+#include <process.h>
+
+class Fiber_Win32 : public Fiber {
+private:
+ LPVOID m_fiber;
+ FiberFunc m_proc;
+ void *m_param;
+ bool m_attached;
+
+ static Fiber_Win32 *s_main;
+
+public:
+ /**
+ * Create a win32 fiber and start it, calling proc(param).
+ */
+ Fiber_Win32(FiberFunc proc, void *param) :
+ m_fiber(NULL),
+ m_proc(proc),
+ m_param(param),
+ m_attached(false)
+ {
+ CreateFiber();
+ }
+
+ /**
+ * Create a win32 fiber and attach current thread to it.
+ */
+ Fiber_Win32(void *param) :
+ m_fiber(NULL),
+ m_proc(NULL),
+ m_param(param),
+ m_attached(true)
+ {
+ ConvertThreadToFiber();
+ if (s_main == NULL) s_main = this;
+ }
+
+ /* virtual */ ~Fiber_Win32()
+ {
+ if (this->m_fiber != NULL) {
+ if (this->m_attached) {
+ this->ConvertFiberToThread();
+ } else {
+ this->DeleteFiber();
+ }
+ }
+ }
+
+ /* virtual */ void SwitchToFiber()
+ {
+ typedef VOID (WINAPI *FnSwitchToFiber)(LPVOID fiber);
+
+ static FnSwitchToFiber fnSwitchToFiber = (FnSwitchToFiber)stGetProcAddr("SwitchToFiber");
+ assert(fnSwitchToFiber != NULL);
+
+ fnSwitchToFiber(this->m_fiber);
+ }
+
+ /* virtual */ void Exit()
+ {
+ /* Simply switch back to the main fiber, we kill the fiber sooner or later */
+ s_main->SwitchToFiber();
+ }
+
+ /* virtual */ bool IsRunning()
+ {
+ return this->m_fiber != NULL;
+ }
+
+ /* virtual */ void *GetFiberData()
+ {
+ return this->m_param;
+ }
+
+ /**
+ * Win95 doesn't have Fiber support. So check if we have Fiber support,
+ * and else fall back on Fiber_Thread.
+ */
+ static bool IsSupported()
+ {
+ static bool first_run = true;
+ static bool is_supported = false;
+
+ if (first_run) {
+ first_run = false;
+ static const char *names[] = {
+ "ConvertThreadToFiber",
+ "CreateFiber",
+ "DeleteFiber",
+ "ConvertFiberToThread",
+ "SwitchToFiber"};
+ for (size_t i = 0; i < lengthof(names); i++) {
+ if (stGetProcAddr(names[i]) == NULL) return false;
+ }
+ is_supported = true;
+ }
+ return is_supported;
+ }
+
+private:
+ /**
+ * Get a function from kernel32.dll.
+ * @param name Function to get.
+ * @return Proc to the function, or NULL when not found.
+ */
+ static FARPROC stGetProcAddr(const char *name)
+ {
+ static HMODULE hKernel = LoadLibraryA("kernel32.dll");
+ return GetProcAddress(hKernel, name);
+ }
+
+ /**
+ * First function which is called within the fiber.
+ */
+ static VOID CALLBACK stFiberProc(LPVOID fiber)
+ {
+ Fiber_Win32 *cur = (Fiber_Win32 *)fiber;
+ cur->m_proc(cur->m_param);
+ }
+
+ /**
+ * Delete a fiber.
+ */
+ void DeleteFiber()
+ {
+ typedef VOID (WINAPI *FnDeleteFiber)(LPVOID lpFiber);
+
+ static FnDeleteFiber fnDeleteFiber = (FnDeleteFiber)stGetProcAddr("DeleteFiber");
+ assert(fnDeleteFiber != NULL);
+
+ fnDeleteFiber(this->m_fiber);
+ this->m_fiber = NULL;
+ }
+
+ /**
+ * Convert a current thread to a fiber.
+ */
+ void ConvertThreadToFiber()
+ {
+ typedef LPVOID (WINAPI *FnConvertThreadToFiber)(LPVOID lpParameter);
+
+ static FnConvertThreadToFiber fnConvertThreadToFiber = (FnConvertThreadToFiber)stGetProcAddr("ConvertThreadToFiber");
+ assert(fnConvertThreadToFiber != NULL);
+
+ this->m_fiber = fnConvertThreadToFiber(this);
+ }
+
+ /**
+ * Create a new fiber.
+ */
+ void CreateFiber()
+ {
+ typedef LPVOID (WINAPI *FnCreateFiber)(SIZE_T dwStackSize, LPFIBER_START_ROUTINE lpStartAddress, LPVOID lpParameter);
+
+ static FnCreateFiber fnCreateFiber = (FnCreateFiber)stGetProcAddr("CreateFiber");
+ assert(fnCreateFiber != NULL);
+
+ this->m_fiber = fnCreateFiber(0, &stFiberProc, this);
+ }
+
+ /**
+ * Convert a fiber back to a thread.
+ */
+ void ConvertFiberToThread()
+ {
+ typedef BOOL (WINAPI *FnConvertFiberToThread)();
+
+ static FnConvertFiberToThread fnConvertFiberToThread = (FnConvertFiberToThread)stGetProcAddr("ConvertFiberToThread");
+ assert(fnConvertFiberToThread != NULL);
+
+ fnConvertFiberToThread();
+ this->m_fiber = NULL;
+ }
+};
+
+/* Initialize the static member of Fiber_Win32 */
+/* static */ Fiber_Win32 *Fiber_Win32::s_main = NULL;
+
+/* Include Fiber_Thread, as Win95 needs it */
+#include "fiber_thread.cpp"
+
+/* static */ Fiber *Fiber::New(FiberFunc proc, void *param)
+{
+ if (Fiber_Win32::IsSupported()) return new Fiber_Win32(proc, param);
+ return new Fiber_Thread(proc, param);
+}
+
+/* static */ Fiber *Fiber::AttachCurrent(void *param)
+{
+ if (Fiber_Win32::IsSupported()) return new Fiber_Win32(param);
+ return new Fiber_Thread(param);
+}
+
+/* static */ void *Fiber::GetCurrentFiberData()
+{
+ if (Fiber_Win32::IsSupported()) return ((Fiber *)::GetFiberData())->GetFiberData();
+ return Fiber_Thread::GetCurrentFiber()->GetFiberData();
+}
diff --git a/src/genworld.cpp b/src/genworld.cpp
index 885e5171e..ca6b89d71 100644
--- a/src/genworld.cpp
+++ b/src/genworld.cpp
@@ -84,7 +84,7 @@ bool IsGenerateWorldThreaded()
/**
* The internal, real, generate function.
*/
-static void *_GenerateWorld(void *arg)
+static void * CDECL _GenerateWorld(void *arg)
{
_generating_world = true;
if (_network_dedicated) DEBUG(net, 0, "Generating map, please wait...");
@@ -194,7 +194,7 @@ void WaitTillGeneratedWorld()
{
if (_gw.thread == NULL) return;
_gw.quit_thread = true;
- OTTDJoinThread((OTTDThread*)_gw.thread);
+ _gw.thread->Join();
_gw.thread = NULL;
_gw.threaded = false;
}
@@ -228,6 +228,8 @@ void HandleGeneratingWorldAbortion()
if (_cursor.sprite == SPR_CURSOR_ZZZ) SetMouseCursor(SPR_CURSOR_MOUSE, PAL_NONE);
/* Show all vital windows again, because we have hidden them */
if (_gw.threaded && _game_mode != GM_MENU) ShowVitalWindows();
+
+ ThreadObject *thread = _gw.thread;
_gw.active = false;
_gw.thread = NULL;
_gw.proc = NULL;
@@ -237,7 +239,7 @@ void HandleGeneratingWorldAbortion()
DeleteWindowById(WC_GENERATE_PROGRESS_WINDOW, 0);
MarkWholeScreenDirty();
- OTTDExitThread();
+ thread->Exit();
}
/**
@@ -282,7 +284,7 @@ void GenerateWorld(int mode, uint size_x, uint size_y)
SetupColorsAndInitialWindow();
if (_network_dedicated ||
- (_gw.thread = OTTDCreateThread(&_GenerateWorld, NULL)) == NULL) {
+ (_gw.thread = ThreadObject::New(&_GenerateWorld, NULL)) == NULL) {
DEBUG(misc, 1, "Cannot create genworld thread, reverting to single-threaded mode");
_gw.threaded = false;
_GenerateWorld(NULL);
diff --git a/src/genworld.h b/src/genworld.h
index ebac04e16..1fc357d1c 100644
--- a/src/genworld.h
+++ b/src/genworld.h
@@ -5,16 +5,6 @@
#ifndef GENWORLD_H
#define GENWORLD_H
-/* If OTTDThread isn't defined, define it to a void, but make sure to undefine
- * it after this include. This makes including genworld.h easier, as you
- * don't need to include thread.h before it, while it stays possible to
- * include it after it, and still work.
- */
-#ifndef OTTDThread
-#define TEMPORARY_OTTDTHREAD_DEFINITION
-#define OTTDThread void
-#endif
-
#include "player_type.h"
/*
@@ -43,14 +33,9 @@ struct gw_info {
uint size_y; ///< Y-size of the map
gw_done_proc *proc; ///< Proc that is called when done (can be NULL)
gw_abort_proc *abortp; ///< Proc that is called when aborting (can be NULL)
- OTTDThread *thread; ///< The thread we are in (can be NULL)
+ class ThreadObject *thread; ///< The thread we are in (can be NULL)
};
-#ifdef TEMPORARY_OTTDTHREAD_DEFINITION
-#undef OTTDThread
-#undef TEMPORARY_OTTDTHREAD_DEFINITION
-#endif
-
enum gwp_class {
GWP_MAP_INIT, ///< Initialize/allocate the map, start economy
GWP_LANDSCAPE, ///< Create the landscape
diff --git a/src/saveload.cpp b/src/saveload.cpp
index cfcbab3c5..00713718b 100644
--- a/src/saveload.cpp
+++ b/src/saveload.cpp
@@ -1499,7 +1499,7 @@ void SaveFileError()
SaveFileDone();
}
-static OTTDThread* save_thread;
+static ThreadObject *save_thread;
/** We have written the whole game into memory, _Savegame_pool, now find
* and appropiate compressor and start writing to file.
@@ -1561,7 +1561,7 @@ static SaveOrLoadResult SaveFileToDisk(bool threaded)
}
}
-static void* SaveFileToDiskThread(void *arg)
+static void * CDECL SaveFileToDiskThread(void *arg)
{
SaveFileToDisk(true);
return NULL;
@@ -1569,7 +1569,9 @@ static void* SaveFileToDiskThread(void *arg)
void WaitTillSaved()
{
- OTTDJoinThread(save_thread);
+ if (save_thread == NULL) return;
+
+ save_thread->Join();
save_thread = NULL;
}
@@ -1641,7 +1643,7 @@ SaveOrLoadResult SaveOrLoad(const char *filename, int mode, Subdirectory sb)
SaveFileStart();
if (_network_server ||
- (save_thread = OTTDCreateThread(&SaveFileToDiskThread, NULL)) == NULL) {
+ (save_thread = ThreadObject::New(&SaveFileToDiskThread, NULL)) == NULL) {
if (!_network_server) DEBUG(sl, 1, "Cannot create savegame thread, reverting to single-threaded mode...");
SaveOrLoadResult result = SaveFileToDisk(false);
diff --git a/src/thread.cpp b/src/thread.cpp
deleted file mode 100644
index 4e4f065fb..000000000
--- a/src/thread.cpp
+++ /dev/null
@@ -1,313 +0,0 @@
-/* $Id$ */
-
-/** @file thread.cpp */
-
-#include "stdafx.h"
-#include "thread.h"
-#include "core/alloc_func.hpp"
-#include <stdlib.h>
-
-#if defined(__AMIGA__) || defined(PSP) || defined(NO_THREADS)
-OTTDThread *OTTDCreateThread(OTTDThreadFunc function, void *arg) { return NULL; }
-void *OTTDJoinThread(OTTDThread *t) { return NULL; }
-void OTTDExitThread() { NOT_REACHED(); };
-
-#elif defined(__OS2__)
-
-#define INCL_DOS
-#include <os2.h>
-#include <process.h>
-
-struct OTTDThread {
- TID thread;
- OTTDThreadFunc func;
- void* arg;
- void* ret;
-};
-
-static void Proxy(void* arg)
-{
- OTTDThread* t = (OTTDThread*)arg;
- t->ret = t->func(t->arg);
-}
-
-OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)
-{
- OTTDThread* t = MallocT<OTTDThread>(1);
-
- if (t == NULL) return NULL;
-
- t->func = function;
- t->arg = arg;
- t->thread = _beginthread(Proxy, NULL, 32768, t);
- if (t->thread != (TID)-1) {
- return t;
- } else {
- free(t);
- return NULL;
- }
-}
-
-void* OTTDJoinThread(OTTDThread* t)
-{
- void* ret;
-
- if (t == NULL) return NULL;
-
- DosWaitThread(&t->thread, DCWW_WAIT);
- ret = t->ret;
- free(t);
- return ret;
-}
-
-void OTTDExitThread()
-{
- _endthread();
-}
-
-#elif defined(UNIX) && !defined(MORPHOS)
-
-#include <pthread.h>
-
-struct OTTDThread {
- pthread_t thread;
-};
-
-OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)
-{
- OTTDThread* t = MallocT<OTTDThread>(1);
-
- if (t == NULL) return NULL;
-
- if (pthread_create(&t->thread, NULL, function, arg) == 0) {
- return t;
- } else {
- free(t);
- return NULL;
- }
-}
-
-void* OTTDJoinThread(OTTDThread* t)
-{
- void* ret;
-
- if (t == NULL) return NULL;
-
- pthread_join(t->thread, &ret);
- free(t);
- return ret;
-}
-
-void OTTDExitThread()
-{
- pthread_exit(NULL);
-}
-
-#elif defined(WIN32)
-
-#include <windows.h>
-
-struct OTTDThread {
- HANDLE thread;
- OTTDThreadFunc func;
- void* arg;
- void* ret;
-};
-
-static DWORD WINAPI Proxy(LPVOID arg)
-{
- OTTDThread* t = (OTTDThread*)arg;
- t->ret = t->func(t->arg);
- return 0;
-}
-
-OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)
-{
- OTTDThread* t = MallocT<OTTDThread>(1);
- DWORD dwThreadId;
-
- if (t == NULL) return NULL;
-
- t->func = function;
- t->arg = arg;
- t->thread = CreateThread(NULL, 0, Proxy, t, 0, &dwThreadId);
-
- if (t->thread != NULL) {
- return t;
- } else {
- free(t);
- return NULL;
- }
-}
-
-void* OTTDJoinThread(OTTDThread* t)
-{
- void* ret;
-
- if (t == NULL) return NULL;
-
- WaitForSingleObject(t->thread, INFINITE);
- CloseHandle(t->thread);
- ret = t->ret;
- free(t);
- return ret;
-}
-
-void OTTDExitThread()
-{
- ExitThread(0);
-}
-
-
-#elif defined(MORPHOS)
-
-#include <exec/types.h>
-#include <exec/rawfmt.h>
-#include <dos/dostags.h>
-
-#include <proto/dos.h>
-#include <proto/exec.h>
-
-#include <setjmp.h>
-
-/* 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
- jmp_buf jumpstore; ///< storage for the setjump state
-};
-
-struct OTTDThread {
- struct MsgPort *replyport;
- struct OTTDThreadStartupMessage msg;
-};
-
-
-/**
- * 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
-
-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) {
- /* Make use of setjmp() here, so this point can be reached again from inside
- * OTTDExitThread() which can be called from anythere inside msg->func.
- * It's a bit ugly and in worst case it leaks some memory. */
- if (setjmp(msg->jumpstore) == 0) {
- msg->ret = msg->func(msg->arg);
- } else {
- KPutStr("[Child] Returned to main()\n");
- }
- }
-
- /* Quit the child, exec.library will reply the startup msg internally. */
- KPutStr("[Child] Done.\n");
-}
-
-OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void *arg)
-{
- OTTDThread *t;
- struct Task *parent;
-
- KPutStr("[OpenTTD] Create thread...\n");
-
- t = (struct OTTDThread *)AllocVecTaskPooled(sizeof(struct OTTDThread));
- if (t == NULL) return NULL;
-
- 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 */
- t->msg.func = function;
- t->msg.arg = arg;
- t->msg.ret = NULL;
-
- t->replyport = CreateMsgPort();
-
- if (t->replyport != NULL) {
- struct Process *child;
-
- t->msg.msg.mn_Node.ln_Type = NT_MESSAGE;
- t->msg.msg.mn_ReplyPort = t->replyport;
- t->msg.msg.mn_Length = sizeof(struct OTTDThreadStartupMessage);
-
- child = CreateNewProcTags(
- NP_CodeType, CODETYPE_PPC,
- NP_Entry, Proxy,
- NP_StartupMsg, (ULONG)&t->msg,
- NP_Priority, 5UL,
- NP_Name, (ULONG)"OpenTTD Thread",
- NP_PPCStackSize, 131072UL,
- TAG_DONE);
-
- if (child != NULL) {
- KPutStr("[OpenTTD] Child process launched.\n");
- return t;
- }
- DeleteMsgPort(t->replyport);
- }
- FreeVecTaskPooled(t);
-
- return NULL;
-}
-
-void* OTTDJoinThread(OTTDThread *t)
-{
- struct OTTDThreadStartupMessage *reply;
- void *ret;
-
- KPutStr("[OpenTTD] Join threads...\n");
-
- if (t == NULL) return NULL;
-
- KPutStr("[OpenTTD] Wait for child to quit...\n");
- WaitPort(t->replyport);
-
- reply = (struct OTTDThreadStartupMessage *)GetMsg(t->replyport);
- ret = reply->ret;
-
- DeleteMsgPort(t->replyport);
- FreeVecTaskPooled(t);
-
- return ret;
-}
-
-void OTTDExitThread()
-{
- struct OTTDThreadStartupMessage *msg;
-
- KPutStr("[Child] Aborting...\n");
-
- if (NewGetTaskAttrs(NULL, &msg, sizeof(struct OTTDThreadStartupMessage *), TASKINFOTYPE_STARTUPMSG, TAG_DONE) && msg != NULL) {
- KPutStr("[Child] Jumping back...\n");
- longjmp(msg->jumpstore, 0xBEAFCAFE);
- }
-
- NOT_REACHED();
-}
-
-#endif
diff --git a/src/thread.h b/src/thread.h
index 5ec169b0c..2b12b4582 100644
--- a/src/thread.h
+++ b/src/thread.h
@@ -5,12 +5,95 @@
#ifndef THREAD_H
#define THREAD_H
-struct OTTDThread;
+typedef void * (CDECL *OTTDThreadFunc)(void *);
-typedef void * (*OTTDThreadFunc)(void*);
+/**
+ * A Thread Object which works on all our supported OSes.
+ */
+class ThreadObject {
+public:
+ /**
+ * Virtual destructor to allow 'delete' operator to work properly.
+ */
+ virtual ~ThreadObject() {};
-OTTDThread *OTTDCreateThread(OTTDThreadFunc, void*);
-void *OTTDJoinThread(OTTDThread*);
-void OTTDExitThread();
+ /**
+ * Check if the thread is currently running.
+ * @return True if the thread is running.
+ */
+ virtual bool IsRunning() = 0;
+
+ /**
+ * Waits for the thread to exit.
+ * @return True if the thread has exited.
+ */
+ virtual bool WaitForStop() = 0;
+
+ /**
+ * Exit this thread.
+ */
+ virtual bool Exit() = 0;
+
+ /**
+ * Join this thread.
+ */
+ virtual void *Join() = 0;
+
+ /**
+ * Check if this thread is the current active thread.
+ * @return True if it is the current active thread.
+ */
+ virtual bool IsCurrent() = 0;
+
+ /**
+ * Get the unique ID of this thread.
+ * @return A value unique to each thread.
+ */
+ virtual uint GetId() = 0;
+
+ /**
+ * Create a thread; proc will be called as first function inside the thread,
+ * with optinal params.
+ * @param proc The procedure to call inside the thread.
+ * @param param The params to give with 'proc'.
+ * @return True if the thread was started correctly.
+ */
+ static ThreadObject *New(OTTDThreadFunc proc, void *param);
+
+ /**
+ * Convert the current thread to a new ThreadObject.
+ * @return A new ThreadObject with the current thread attached to it.
+ */
+ static ThreadObject* AttachCurrent();
+
+ /**
+ * Find the Id of the current running thread.
+ * @return The thread ID of the current active thread.
+ */
+ static uint CurrentId();
+};
+
+/**
+ * Cross-platform Thread Semaphore. Wait() waits for a Set() of someone else.
+ */
+class ThreadSemaphore {
+public:
+ static ThreadSemaphore *New();
+
+ /**
+ * Virtual Destructor to avoid compiler warnings.
+ */
+ virtual ~ThreadSemaphore() {};
+
+ /**
+ * Signal all threads that are in Wait() to continue.
+ */
+ virtual void Set() = 0;
+
+ /**
+ * Wait until we are signaled by a call to Set().
+ */
+ virtual void Wait() = 0;
+};
#endif /* THREAD_H */
diff --git a/src/thread_none.cpp b/src/thread_none.cpp
new file mode 100644
index 000000000..6209e89a7
--- /dev/null
+++ b/src/thread_none.cpp
@@ -0,0 +1,42 @@
+/* $Id$ */
+
+/** @file thread_none.cpp No-Threads-Available implementation of Threads */
+
+#include "stdafx.h"
+#include "thread.h"
+#include "fiber.hpp"
+
+/* static */ ThreadObject *ThreadObject::New(OTTDThreadFunc proc, void *param)
+{
+ return NULL;
+}
+
+/* static */ ThreadObject *ThreadObject::AttachCurrent()
+{
+ return NULL;
+}
+
+/* static */ uint ThreadObject::CurrentId()
+{
+ return -1;
+}
+
+/* static */ ThreadSemaphore *ThreadSemaphore::New()
+{
+ return NULL;
+}
+
+/* static */ Fiber *Fiber::New(FiberFunc proc, void *param)
+{
+ return NULL;
+}
+
+/* static */ Fiber *Fiber::AttachCurrent(void *param)
+{
+ return NULL;
+}
+
+/* static */ void *Fiber::GetCurrentFiberData()
+{
+ return NULL;
+}
diff --git a/src/thread_os2.cpp b/src/thread_os2.cpp
new file mode 100644
index 000000000..29b33557f
--- /dev/null
+++ b/src/thread_os2.cpp
@@ -0,0 +1,80 @@
+/* $Id$ */
+
+/** @file thread_os2.cpp OS2 implementation of Threads. */
+
+#include "stdafx.h"
+#include "thread.h"
+
+#if 0
+#include "debug.h"
+#include "core/alloc_func.hpp"
+#include <stdlib.h>
+
+#define INCL_DOS
+#include <os2.h>
+#include <process.h>
+
+struct OTTDThread {
+ TID thread;
+ OTTDThreadFunc func;
+ void *arg;
+ void *ret;
+};
+
+static void Proxy(void *arg)
+{
+ OTTDThread *t = (OTTDThread *)arg;
+ t->ret = t->func(t->arg);
+}
+
+OTTDThread *OTTDCreateThread(OTTDThreadFunc function, void *arg)
+{
+ OTTDThread *t = MallocT<OTTDThread>(1);
+
+ t->func = function;
+ t->arg = arg;
+ t->thread = _beginthread(Proxy, NULL, 32768, t);
+ if (t->thread != (TID)-1) {
+ return t;
+ } else {
+ free(t);
+ return NULL;
+ }
+}
+
+void *OTTDJoinThread(OTTDThread *t)
+{
+ if (t == NULL) return NULL;
+
+ DosWaitThread(&t->thread, DCWW_WAIT);
+ void *ret = t->ret;
+ free(t);
+ return ret;
+}
+
+void OTTDExitThread()
+{
+ _endthread();
+}
+
+#endif
+
+/* static */ ThreadObject *ThreadObject::New(OTTDThreadFunc proc, void *param)
+{
+ return NULL;
+}
+
+/* static */ ThreadObject *ThreadObject::AttachCurrent()
+{
+ return NULL;
+}
+
+/* static */ uint ThreadObject::CurrentId()
+{
+ return -1;
+}
+
+/* static */ ThreadSemaphore *ThreadSemaphore::New()
+{
+ return NULL;
+}
diff --git a/src/thread_pthread.cpp b/src/thread_pthread.cpp
new file mode 100644
index 000000000..7aa0fda18
--- /dev/null
+++ b/src/thread_pthread.cpp
@@ -0,0 +1,199 @@
+/* $Id$ */
+
+/** @file thread_pthread.cpp POSIX pthread implementation of Threads. */
+
+#include "stdafx.h"
+#include "thread.h"
+#include "debug.h"
+#include "core/alloc_func.hpp"
+#include <stdlib.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <unistd.h>
+
+/**
+ * POSIX pthread version for ThreadObject.
+ */
+class ThreadObject_pthread : public ThreadObject {
+private:
+ pthread_t m_thr; ///< System thread identifier.
+ OTTDThreadFunc m_proc; ///< External thread procedure.
+ void *m_param; ///< Parameter for the external thread procedure.
+ bool m_attached; ///< True if the ThreadObject was attached to an existing thread.
+ sem_t m_sem_start; ///< Here the new thread waits before it starts.
+ sem_t m_sem_stop; ///< Here the other thread can wait for this thread to end.
+
+public:
+ /**
+ * Create a pthread and start it, calling proc(param).
+ */
+ ThreadObject_pthread(OTTDThreadFunc proc, void *param) :
+ m_thr(0),
+ m_proc(proc),
+ m_param(param),
+ m_attached(false)
+ {
+ sem_init(&m_sem_start, 0, 0);
+ sem_init(&m_sem_stop, 0, 0);
+
+ pthread_create(&m_thr, NULL, &stThreadProc, this);
+ sem_post(&m_sem_start);
+ }
+
+ /**
+ * Create a pthread and attach current thread to it.
+ */
+ ThreadObject_pthread() :
+ m_thr(0),
+ m_proc(NULL),
+ m_param(0),
+ m_attached(true)
+ {
+ sem_init(&m_sem_start, 0, 0);
+ sem_init(&m_sem_stop, 0, 0);
+
+ m_thr = pthread_self();
+ }
+
+ /* virtual */ ~ThreadObject_pthread()
+ {
+ sem_destroy(&m_sem_stop);
+ sem_destroy(&m_sem_start);
+ };
+
+ /* 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;
+
+ int ret = sem_wait(&m_sem_stop);
+ if (ret == 0) {
+ /* We have passed semaphore so increment it again */
+ sem_post(&m_sem_stop);
+ return true;
+ }
+ return false;
+ }
+
+ /* virtual */ bool Exit()
+ {
+ /* You can only exit yourself */
+ assert(IsCurrent());
+ /* If the thread is not running, we are already closed */
+ if (!IsRunning()) return false;
+
+ /* For now we terminate by throwing an error, gives much cleaner cleanup */
+ throw 0;
+ }
+
+ /* virtual */ void *Join()
+ {
+ /* You cannot join yourself */
+ assert(!IsCurrent());
+
+ void *ret;
+ pthread_join(m_thr, &ret);
+ m_thr = 0;
+
+ return ret;
+ }
+
+ /* virtual */ bool IsCurrent()
+ {
+ return pthread_self() == 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 *stThreadProc(void *thr)
+ {
+ return ((ThreadObject_pthread *)thr)->ThreadProc();
+ }
+
+ /**
+ * A new thread is created, and this function is called. Call the custom
+ * function of the creator of the thread.
+ */
+ void *ThreadProc()
+ {
+ /* The new thread stops here so the calling thread can complete pthread_create() call */
+ sem_wait(&m_sem_start);
+
+ /* Call the proc of the creator to continue this thread */
+ try {
+ m_proc(m_param);
+ } catch (...) {
+ }
+
+ /* Notify threads waiting for our completion */
+ sem_post(&m_sem_stop);
+
+ return NULL;
+ }
+};
+
+/* static */ ThreadObject *ThreadObject::New(OTTDThreadFunc proc, void *param)
+{
+ return new ThreadObject_pthread(proc, param);
+}
+
+/* static */ ThreadObject *ThreadObject::AttachCurrent()
+{
+ return new ThreadObject_pthread();
+}
+
+/* static */ uint ThreadObject::CurrentId()
+{
+ return (uint)pthread_self();
+}
+
+
+/**
+ * POSIX pthread version of ThreadSemaphore.
+ */
+class ThreadSemaphore_pthread : public ThreadSemaphore {
+private:
+ sem_t m_sem;
+
+public:
+ ThreadSemaphore_pthread()
+ {
+ sem_init(&m_sem, 0, 0);
+ }
+
+ /* virtual */ ~ThreadSemaphore_pthread()
+ {
+ sem_destroy(&m_sem);
+ }
+
+ /* virtual */ void Set()
+ {
+ int val = 0;
+ if (sem_getvalue(&m_sem, &val) == 0 && val == 0) sem_post(&m_sem);
+ }
+
+ /* virtual */ void Wait()
+ {
+ sem_wait(&m_sem);
+ }
+};
+
+/* static */ ThreadSemaphore *ThreadSemaphore::New()
+{
+ return new ThreadSemaphore_pthread();
+}
diff --git a/src/thread_win32.cpp b/src/thread_win32.cpp
new file mode 100644
index 000000000..778bee9bf
--- /dev/null
+++ b/src/thread_win32.cpp
@@ -0,0 +1,188 @@
+/* $Id$ */
+
+/** @file thread_win32.cpp Win32 thread implementation of Threads. */
+
+#include "stdafx.h"
+#include "thread.h"
+#include "debug.h"
+#include "core/alloc_func.hpp"
+#include <stdlib.h>
+#include <windows.h>
+#include <process.h>
+
+/**
+ * Win32 thread version for ThreadObject.
+ */
+class ThreadObject_Win32 : public ThreadObject {
+private:
+ uint m_id_thr;
+ HANDLE m_h_thr;
+ OTTDThreadFunc m_proc;
+ void *m_param;
+ bool m_attached;
+ void *ret;
+
+public:
+ /**
+ * Create a win32 thread and start it, calling proc(param).
+ */
+ ThreadObject_Win32(OTTDThreadFunc proc, void *param) :
+ m_id_thr(0),
+ m_h_thr(NULL),
+ m_proc(proc),
+ m_param(param),
+ m_attached(false)
+ {
+ m_h_thr = (HANDLE)_beginthreadex(NULL, 0, &stThreadProc, this, CREATE_SUSPENDED, &m_id_thr);
+ if (m_h_thr == NULL) return;
+ ResumeThread(m_h_thr);
+ }
+
+ /**
+ * Create a win32 thread and attach current thread to it.
+ */
+ ThreadObject_Win32() :
+ m_id_thr(0),
+ m_h_thr(NULL),
+ m_proc(NULL),
+ m_param(NULL),
+ m_attached(false)
+ {
+ BOOL ret = DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &m_h_thr, 0, FALSE, DUPLICATE_SAME_ACCESS);
+ if (!ret) return;
+ m_id_thr = GetCurrentThreadId();
+ }
+
+ /* virtual */ ~ThreadObject_Win32()
+ {
+ if (m_h_thr != NULL) {
+ CloseHandle(m_h_thr);
+ m_h_thr = NULL;
+ }
+ }
+
+ /* virtual */ bool IsRunning()
+ {
+ if (m_h_thr == NULL) return false;
+ DWORD exit_code = 0;
+ if (!GetExitCodeThread(m_h_thr, &exit_code)) return false;
+ return (exit_code == STILL_ACTIVE);
+ }
+
+ /* virtual */ bool WaitForStop()
+ {
+ /* You can't wait on yourself */
+ assert(!IsCurrent());
+ /* If the thread is not running, waiting is over */
+ if (!IsRunning()) return true;
+
+ DWORD res = WaitForSingleObject(m_h_thr, INFINITE);
+ return res == WAIT_OBJECT_0;
+ }
+
+ /* virtual */ bool Exit()
+ {
+ /* You can only exit yourself */
+ assert(IsCurrent());
+ /* If the thread is not running, we are already closed */
+ if (!IsRunning()) return false;
+
+ /* For now we terminate by throwing an error, gives much cleaner cleanup */
+ throw 0;
+ }
+
+ /* virtual */ void *Join()
+ {
+ /* You cannot join yourself */
+ assert(!IsCurrent());
+
+ WaitForSingleObject(m_h_thr, INFINITE);
+
+ return this->ret;
+ }
+
+ /* virtual */ bool IsCurrent()
+ {
+ DWORD id_cur = GetCurrentThreadId();
+ return id_cur == m_id_thr;
+ }
+
+ /* virtual */ uint GetId()
+ {
+ return m_id_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 uint CALLBACK stThreadProc(void *thr)
+ {
+ return ((ThreadObject_Win32 *)thr)->ThreadProc();
+ }
+
+ /**
+ * A new thread is created, and this function is called. Call the custom
+ * function of the creator of the thread.
+ */
+ uint ThreadProc()
+ {
+ try {
+ this->ret = m_proc(m_param);
+ } catch (...) {
+ }
+
+ return 0;
+ }
+};
+
+/* static */ ThreadObject *ThreadObject::New(OTTDThreadFunc proc, void *param)
+{
+ return new ThreadObject_Win32(proc, param);
+}
+
+/* static */ ThreadObject* ThreadObject::AttachCurrent()
+{
+ return new ThreadObject_Win32();
+}
+
+/* static */ uint ThreadObject::CurrentId()
+{
+ return GetCurrentThreadId();
+}
+
+
+/**
+ * Win32 thread version of ThreadSemaphore.
+ */
+class ThreadSemaphore_Win32 : public ThreadSemaphore {
+private:
+ HANDLE m_handle;
+
+public:
+ ThreadSemaphore_Win32()
+ {
+ m_handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);
+ }
+
+ /* virtual */ ~ThreadSemaphore_Win32()
+ {
+ ::CloseHandle(m_handle);
+ }
+
+ /* virtual */ void Set()
+ {
+ ::SetEvent(m_handle);
+ }
+
+ /* virtual */ void Wait()
+ {
+ ::WaitForSingleObject(m_handle, INFINITE);
+ }
+};
+
+/* static */ ThreadSemaphore *ThreadSemaphore::New()
+{
+ return new ThreadSemaphore_Win32();
+}