1

/* $Id$ */

     2

     3

/** @file thread.cpp */

     4

     5

#include "stdafx.h"

     6

#include "thread.h"

     7

#include <stdlib.h>

     8

#include "helpers.hpp"

     9

    10

#if defined(__AMIGA__) || defined(PSP) || defined(NO_THREADS)

    11

OTTDThread *OTTDCreateThread(OTTDThreadFunc function, void *arg) { return NULL; }

    12

void *OTTDJoinThread(OTTDThread *t) { return NULL; }

    13

void OTTDExitThread() { NOT_REACHED(); };

    14

    15

#elif defined(__OS2__)

    16

    17

#define INCL_DOS

    18

#include <os2.h>

    19

#include <process.h>

    20

    21

struct OTTDThread {

    22

	TID thread;

    23

	OTTDThreadFunc func;

    24

	void* arg;

    25

	void* ret;

    26

};

    27

    28

static void Proxy(void* arg)

    29

{

    30

	OTTDThread* t = (OTTDThread*)arg;

    31

	t->ret = t->func(t->arg);

    32

}

    33

    34

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    35

{

    36

	OTTDThread* t = MallocT<OTTDThread>(1);

    37

    38

	if (t == NULL) return NULL;

    39

    40

	t->func = function;

    41

	t->arg  = arg;

    42

	t->thread = _beginthread(Proxy, NULL, 32768, t);

    43

	if (t->thread != (TID)-1) {

    44

		return t;

    45

	} else {

    46

		free(t);

    47

		return NULL;

    48

	}

    49

}

    50

    51

void* OTTDJoinThread(OTTDThread* t)

    52

{

    53

	void* ret;

    54

    55

	if (t == NULL) return NULL;

    56

    57

	DosWaitThread(&t->thread, DCWW_WAIT);

    58

	ret = t->ret;

    59

	free(t);

    60

	return ret;

    61

}

    62

    63

void OTTDExitThread()

    64

{

    65

	_endthread();

    66

}

    67

    68

#elif defined(UNIX) && !defined(MORPHOS)

    69

    70

#include <pthread.h>

    71

    72

struct OTTDThread {

    73

	pthread_t thread;

    74

};

    75

    76

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    77

{

    78

	OTTDThread* t = MallocT<OTTDThread>(1);

    79

    80

	if (t == NULL) return NULL;

    81

    82

	if (pthread_create(&t->thread, NULL, function, arg) == 0) {

    83

		return t;

    84

	} else {

    85

		free(t);

    86

		return NULL;

    87

	}

    88

}

    89

    90

void* OTTDJoinThread(OTTDThread* t)

    91

{

    92

	void* ret;

    93

    94

	if (t == NULL) return NULL;

    95

    96

	pthread_join(t->thread, &ret);

    97

	free(t);

    98

	return ret;

    99

}

   100

   101

void OTTDExitThread()

   102

{

   103

	pthread_exit(NULL);

   104

}

   105

   106

#elif defined(WIN32)

   107

   108

#include <windows.h>

   109

   110

struct OTTDThread {

   111

	HANDLE thread;

   112

	OTTDThreadFunc func;

   113

	void* arg;

   114

	void* ret;

   115

};

   116

   117

static DWORD WINAPI Proxy(LPVOID arg)

   118

{

   119

	OTTDThread* t = (OTTDThread*)arg;

   120

	t->ret = t->func(t->arg);

   121

	return 0;

   122

}

   123

   124

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

   125

{

   126

	OTTDThread* t = MallocT<OTTDThread>(1);

   127

	DWORD dwThreadId;

   128

   129

	if (t == NULL) return NULL;

   130

   131

	t->func = function;

   132

	t->arg  = arg;

   133

	t->thread = CreateThread(NULL, 0, Proxy, t, 0, &dwThreadId);

   134

   135

	if (t->thread != NULL) {

   136

		return t;

   137

	} else {

   138

		free(t);

   139

		return NULL;

   140

	}

   141

}

   142

   143

void* OTTDJoinThread(OTTDThread* t)

   144

{

   145

	void* ret;

   146

   147

	if (t == NULL) return NULL;

   148

   149

	WaitForSingleObject(t->thread, INFINITE);

   150

	CloseHandle(t->thread);

   151

	ret = t->ret;

   152

	free(t);

   153

	return ret;

   154

}

   155

   156

void OTTDExitThread()

   157

{

   158

	ExitThread(0);

   159

}

   160

   161

   162

#elif defined(MORPHOS)

   163

   164

#include <exec/types.h>

   165

#include <exec/rawfmt.h>

   166

#include <dos/dostags.h>

   167

   168

#include <proto/dos.h>

   169

#include <proto/exec.h>

   170

   171

#include <setjmp.h>

   172

   173

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

   174

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

   175

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

   176

   177

struct OTTDThreadStartupMessage {

   178

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

   179

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

   180

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

   181

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

   182

	jmp_buf jumpstore;   ///< storage for the setjump state

   183

};

   184

   185

struct OTTDThread {

   186

	struct MsgPort *replyport;

   187

	struct OTTDThreadStartupMessage msg;

   188

};

   189

   190

   191

/**

   192

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

   193

 *  utilize serial/ramdebug instead.

   194

 */

   195

#ifndef NO_DEBUG_MESSAGES

   196

void KPutStr(CONST_STRPTR format)

   197

{

   198

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

   199

}

   200

#else

   201

#define KPutStr(x)

   202

#endif

   203

   204

static void Proxy(void)

   205

{

   206

	struct Task *child = FindTask(NULL);

   207

	struct OTTDThreadStartupMessage *msg;

   208

   209

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

   210

	SetTaskPri(child, -5);

   211

   212

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

   213

   214

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

   215

		/* Make use of setjmp() here, so this point can be reached again from inside

   216

		 *  OTTDExitThread() which can be called from anythere inside msg->func.

   217

		 *  It's a bit ugly and in worst case it leaks some memory. */

   218

		if (setjmp(msg->jumpstore) == 0) {

   219

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

   220

		} else {

   221

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

   222

		}

   223

	}

   224

   225

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

   226

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

   227

}

   228

   229

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void *arg)

   230

{

   231

	OTTDThread *t;

   232

	struct Task *parent;

   233

   234

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

   235

   236

	t = (struct OTTDThread *)AllocVecTaskPooled(sizeof(struct OTTDThread));

   237

	if (t == NULL) return NULL;

   238

   239

	parent = FindTask(NULL);

   240

   241

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

   242

	SetTaskPri(parent, 0);

   243

   244

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

   245

	t->msg.func = function;

   246

	t->msg.arg  = arg;

   247

	t->msg.ret  = NULL;

   248

   249

	t->replyport = CreateMsgPort();

   250

   251

	if (t->replyport != NULL) {

   252

		struct Process *child;

   253

   254

		t->msg.msg.mn_Node.ln_Type = NT_MESSAGE;

   255

		t->msg.msg.mn_ReplyPort    = t->replyport;

   256

		t->msg.msg.mn_Length       = sizeof(struct OTTDThreadStartupMessage);

   257

   258

		child = CreateNewProcTags(

   259

			NP_CodeType,     CODETYPE_PPC,

   260

			NP_Entry,        Proxy,

   261

			NP_StartupMsg,   (ULONG)&t->msg,

   262

			NP_Priority,     5UL,

   263

			NP_Name,         (ULONG)"OpenTTD Thread",

   264

			NP_PPCStackSize, 131072UL,

   265

			TAG_DONE);

   266

   267

		if (child != NULL) {

   268

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

   269

			return t;

   270

		}

   271

		DeleteMsgPort(t->replyport);

   272

	}

   273

	FreeVecTaskPooled(t);

   274

   275

	return NULL;

   276

}

   277

   278

void* OTTDJoinThread(OTTDThread *t)

   279

{

   280

	struct OTTDThreadStartupMessage *reply;

   281

	void *ret;

   282

   283

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

   284

   285

	if (t == NULL) return NULL;

   286

   287

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

   288

	WaitPort(t->replyport);

   289

   290

	reply = (struct OTTDThreadStartupMessage *)GetMsg(t->replyport);

   291

	ret   = reply->ret;

   292

   293

	DeleteMsgPort(t->replyport);

   294

	FreeVecTaskPooled(t);

   295

   296

	return ret;

   297

}

   298

   299

void OTTDExitThread()

   300

{

   301

	struct OTTDThreadStartupMessage *msg;

   302

   303

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

   304

   305

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

   306

		KPutStr("[Child] Jumping back...\n");

   307

		longjmp(msg->jumpstore, 0xBEAFCAFE);

   308

	}

   309

   310

	NOT_REACHED();

   311

}

   312

   313

#endif