1

/* $Id$ */

     2

     3

/** @file thread.cpp */

     4

     5

#include "stdafx.h"

     6

#include "thread.h"

     7

#include "debug.h"

     9

#include <stdlib.h>

    10

    11

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

    12

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

    13

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

    14

void OTTDExitThread() { NOT_REACHED(); };

    15

    16

#elif defined(__OS2__)

    17

    18

#define INCL_DOS

    19

#include <os2.h>

    20

#include <process.h>

    21

    22

struct OTTDThread {

    23

	TID thread;

    24

	OTTDThreadFunc func;

    25

	void* arg;

    26

	void* ret;

    27

};

    28

    29

static void Proxy(void* arg)

    30

{

    31

	OTTDThread* t = (OTTDThread*)arg;

    32

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

    33

}

    34

    35

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    36

{

    37

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

    38

    39

	if (t == NULL) return NULL;

    40

    41

	t->func = function;

    42

	t->arg  = arg;

    43

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

    44

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

    45

		return t;

    46

	} else {

    47

		free(t);

    48

		return NULL;

    49

	}

    50

}

    51

    52

void* OTTDJoinThread(OTTDThread* t)

    53

{

    54

	void* ret;

    55

    56

	if (t == NULL) return NULL;

    57

    58

	DosWaitThread(&t->thread, DCWW_WAIT);

    59

	ret = t->ret;

    60

	free(t);

    61

	return ret;

    62

}

    63

    64

void OTTDExitThread()

    65

{

    66

	_endthread();

    67

}

    68

    69

#elif defined(UNIX)

    70

    71

#include <pthread.h>

    72

#include <semaphore.h>

    73

#include <unistd.h>

    74

    75

struct OTTDThread {

    76

	pthread_t thread;

    77

};

    78

    79

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

    80

{

    81

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

    82

    83

	if (t == NULL) return NULL;

    84

    85

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

    86

		return t;

    87

	} else {

    88

		free(t);

    89

		return NULL;

    90

	}

    91

}

    92

    93

void* OTTDJoinThread(OTTDThread* t)

    94

{

    95

	void* ret;

    96

    97

	if (t == NULL) return NULL;

    98

    99

	pthread_join(t->thread, &ret);

   100

	free(t);

   101

	return ret;

   102

}

   103

   104

void OTTDExitThread()

   105

{

   106

	pthread_exit(NULL);

   107

}

   108

   109

   110

/**

   111

 * C++ thread wrapper - posix pthread version

   112

 */

   113

struct ThreadObject_pthread : public ThreadObject {

   114

	pthread_t m_thr;             ///< system thread identifier

   115

	void (CDECL *m_proc)(void*); ///< external thread procedure

   116

	void      *m_param;          ///< parameter for the external thread procedure

   117

	bool      m_attached;        ///< true if the ThreadObject was attached to an existing thread

   118

	sem_t     m_sem_start;       ///< here the new thread waits before it starts

   119

	sem_t     m_sem_stop;        ///< here the other thread can wait for this thread to end

   120

   121

	ThreadObject_pthread()

   122

		: m_thr(0)

   123

		, m_proc(NULL)

   124

		, m_param(NULL)

   125

		, m_attached(false)

   126

	{

   127

		sem_init(&m_sem_start, 0, 0);

   128

		sem_init(&m_sem_stop, 0, 0);

   129

	}

   130

   131

	/** Virtual destructor to allow 'delete' operator to work properly. */

   132

	/*virtual*/ ~ThreadObject_pthread()

   133

	{

   134

		sem_destroy(&m_sem_stop);

   135

		sem_destroy(&m_sem_start);

   136

	};

   137

   138

	/** Returns true if thread is running. */

   139

	/*virtual*/ bool IsRunning()

   140

	{

   141

		return m_thr != 0;

   142

	}

   143

   144

	/** Waits for the thread exit. Returns true if thread exited. */

   145

	/*virtual*/ bool WaitForStop()

   146

	{

   147

		assert(!IsCurrent());

   148

		int ret = sem_wait(&m_sem_stop);

   149

		if (ret == 0) {

   150

			/* we have passed semaphore so increment it again */

   151

			sem_post(&m_sem_stop);

   152

			return true;

   153

		}

   154

		return false;

   155

	}

   156

   157

	/** Returns true if this Thread Object belongs to the current (calling) thread. */

   158

	/*virtual*/ bool IsCurrent()

   159

	{

   160

		return pthread_self() == m_thr;

   161

	}

   162

   163

	/** Returns thread id of the thread associated to this Thread Object. */

   164

	/*virtual*/ uint Id()

   165

	{

   166

		return (uint)m_thr;

   167

	}

   168

   169

	/** Begin thread execution by calling given procedure and passing given parameter to it. */

   170

	/*virtual*/ bool Begin(void (CDECL *proc)(void*), void *param)

   171

	{

   172

		m_proc = proc;

   173

		m_param = param;

   174

		pthread_create(&m_thr, NULL, &stThreadProc, this);

   175

		sem_post(&m_sem_start);

   176

		return true;

   177

	}

   178

   179

	/** Thread procedure that is called by new thread. */

   180

	static void* stThreadProc(void *thr)

   181

	{

   182

		return ((ThreadObject_pthread*)thr)->ThreadProc();

   183

	}

   184

   185

	/** Thread method that is called by new thread. */

   186

	void* ThreadProc()

   187

	{

   188

		/* the new thread stops here so the calling thread can complete pthread_create() call */

   189

		sem_wait(&m_sem_start);

   190

		try {

   191

			m_proc(m_param);

   192

		} catch (...) {

   193

			DEBUG(misc, 0, "Exception in thread %u!", Id());

   194

		}

   195

		m_thr = 0;

   196

		/* notify threads waiting for our completion */

   197

		sem_post(&m_sem_stop);

   198

		return NULL;

   199

	}

   200

};

   201

   202

/** Used to construct new instance of thread object. */

   203

/*static*/ ThreadObject* ThreadObject::New()

   204

{

   205

	ThreadObject_pthread *thr = new ThreadObject_pthread();

   206

	return thr;

   207

}

   208

   209

/** Returns thread object instance that belongs to the current (calling) thread. */

   210

/*static*/ ThreadObject* ThreadObject::Current()

   211

{

   212

	ThreadObject_pthread *thr = new ThreadObject_pthread();

   213

	thr->m_thr = pthread_self();

   214

	thr->m_attached = true;

   215

	return thr;

   216

}

   217

   218

/** Returns thread id of the current (calling) thread. */

   219

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

   220

{

   221

	return (uint)pthread_self();

   222

}

   223

   224

   225

/**

   226

 * Event object that is signaled manually by Set() and reset automatically when thread passes Wait().

   227

 */

   228

struct AutoResetEvent_pthread : public AutoResetEvent {

   229

	sem_t m_sem;

   230

   231

	AutoResetEvent_pthread()

   232

	{

   233

		sem_init(&m_sem, 0, 0);

   234

	}

   235

   236

	/** Virtual destructor to allow 'delete' operator to work properly. */

   237

	/*virtual*/ ~AutoResetEvent_pthread()

   238

	{

   239

		sem_destroy(&m_sem);

   240

	}

   241

   242

	/** Set the event state to signaled so that one thread can pass the Wait() method. */

   243

	/*virtual*/ void Set()

   244

	{

   245

		int val = 0;

   246

		if (sem_getvalue(&m_sem, &val) == 0 && val == 0) sem_post(&m_sem);

   247

	}

   248

   249

	/** Wait until event is signaled by calling Set() */

   250

	/*virtual*/ void Wait()

   251

	{

   252

		sem_wait(&m_sem);

   253

	}

   254

   255

};

   256

   257

/** Used to construct new instance of event object. */

   258

/*static*/ AutoResetEvent* AutoResetEvent::New()

   259

{

   260

	AutoResetEvent_pthread *evt = new AutoResetEvent_pthread();

   261

	return evt;

   262

}

   263

   264

#elif defined(WIN32)

   265

   266

#include <windows.h>

   267

#include <process.h>

   268

   269

struct OTTDThread {

   270

	HANDLE thread;

   271

	uint   thread_id;

   272

	OTTDThreadFunc func;

   273

	void* arg;

   274

	void* ret;

   275

};

   276

   277

static unsigned WINAPI Proxy(LPVOID arg)

   278

{

   279

	OTTDThread* t = (OTTDThread*)arg;

   280

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

   281

	return 0;

   282

}

   283

   284

OTTDThread* OTTDCreateThread(OTTDThreadFunc function, void* arg)

   285

{

   286

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

   287

   288

	if (t == NULL) return NULL;

   289

   290

	t->func = function;

   291

	t->arg  = arg;

   292

	t->thread = (HANDLE)_beginthreadex(NULL, 0, Proxy, t, 0, &t->thread_id);

   293

   294

	if (t->thread != NULL) {

   295

		return t;

   296

	} else {

   297

		free(t);

   298

		return NULL;

   299

	}

   300

}

   301

   302

void* OTTDJoinThread(OTTDThread* t)

   303

{

   304

	void* ret;

   305

   306

	if (t == NULL) return NULL;

   307

   308

	WaitForSingleObject(t->thread, INFINITE);

   309

	CloseHandle(t->thread);

   310

	ret = t->ret;

   311

	free(t);

   312

	return ret;

   313

}

   314

   315

void OTTDExitThread()

   316

{

   317

	_endthreadex(0);

   318

}

   319

   320

/**

   321

 * C++ thread wrapper interface

   322

 */

   323

struct ThreadObject_Win32 : public ThreadObject {

   324

	uint     m_id_thr;

   325

	HANDLE   m_h_thr;

   326

	void (CDECL *m_proc)(void*);

   327

	void     *m_param;

   328

	bool     m_attached;

   329

   330

	ThreadObject_Win32()

   331

		: m_id_thr(0)

   332

		, m_h_thr(NULL)

   333

		, m_proc(NULL)

   334

		, m_param(NULL)

   335

		, m_attached(false)

   336

	{}

   337

   338

	/** Virtual destructor to allow 'delete' operator to work properly. */

   339

	/*virtual*/ ~ThreadObject_Win32()

   340

	{

   341

		if (m_h_thr != NULL) {

   342

			CloseHandle(m_h_thr);

   343

			m_h_thr = NULL;

   344

		}

   345

	}

   346

   347

	/** Returns true if thread is running. */

   348

	/*virtual*/ bool IsRunning()

   349

	{

   350

		if (m_h_thr == NULL) return false;

   351

		DWORD exit_code = 0;

   352

		if (!GetExitCodeThread(m_h_thr, &exit_code)) return false;

   353

		return (exit_code == STILL_ACTIVE);

   354

	}

   355

   356

	/** Waits for the thread exit. Returns true if thread exited. */

   357

	virtual bool WaitForStop()

   358

	{

   359

		assert(!IsCurrent());

   360

		if (!IsRunning()) return true;

   361

		DWORD res = WaitForSingleObject(m_h_thr, INFINITE);

   362

		return res == WAIT_OBJECT_0;

   363

	}

   364

   365

	/** Returns true if this Thread Object belongs to the current (calling) thread. */

   366

	/*virtual*/ bool IsCurrent()

   367

	{

   368

		DWORD id_cur = GetCurrentThreadId();

   369

		return id_cur == m_id_thr;

   370

	}

   371

   372

	/** Returns thread id of the thread associated to this Thread Object. */

   373

	/*virtual*/ uint Id()

   374

	{

   375

		return m_id_thr;

   376

	}

   377

   378

	/** Begin thread execution by calling given procedure and passing given parameter to it. */

   379

	/*virtual*/ bool Begin(void (CDECL *proc)(void*), void *param)

   380

	{

   381

		assert(m_attached || !IsRunning());

   382

		m_attached = false;

   383

		m_proc = proc;

   384

		m_param = param;

   385

		m_h_thr = (HANDLE)_beginthreadex(NULL, 0, &stThreadProc, this, CREATE_SUSPENDED, &m_id_thr);

   386

		if (m_h_thr == NULL) return false;

   387

		ResumeThread(m_h_thr);

   388

		return true;

   389

	}

   390

   391

	/** Thread procedure that is called by new thread. */

   392

	static uint CALLBACK stThreadProc(void *thr)

   393

	{

   394

		return ((ThreadObject_Win32*)thr)->ThreadProc();

   395

	}

   396

   397

	/** Thread method that is called by new thread. */

   398

	uint ThreadProc()

   399

	{

   400

		uint id_thr = m_id_thr;

   401

		try {

   402

			m_proc(m_param);

   403

		} catch (...) {

   404

			DEBUG(misc, 0, "Exception in thread %d!", id_thr);

   405

		}

   406

		return 0;

   407

	}

   408

   409

	/** Associates the current (caller) thread with this Thread Object. */

   410

	bool AttachCurrent()

   411

	{

   412

		assert(m_h_thr == NULL);

   413

		BOOL ret = DuplicateHandle(GetCurrentProcess(), GetCurrentThread(), GetCurrentProcess(), &m_h_thr, 0, FALSE, DUPLICATE_SAME_ACCESS);

   414

		if (!ret) return false;

   415

		m_id_thr = GetCurrentThreadId();

   416

		m_attached = true;

   417

		return true;

   418

	}

   419

};

   420

   421

/** Used to construct new instance of thread object. */

   422

/*static*/ ThreadObject* ThreadObject::New()

   423

{

   424

	ThreadObject_Win32 *thr = new ThreadObject_Win32;

   425

	return thr;

   426

}

   427

   428

/** Returns thread object instance that belongs to the current (calling) thread. */

   429

/*static*/ ThreadObject* ThreadObject::Current()

   430

{

   431

	ThreadObject_Win32 *thr = new ThreadObject_Win32;

   432

	if (!thr->AttachCurrent()) {

   433

		/* attach failed */

   434

		delete thr;

   435

		return NULL;

   436

	}

   437

	return thr;

   438

}

   439

   440

/** Returns thread id of the current (calling) thread. */

   441

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

   442

{

   443

	return GetCurrentThreadId();

   444

}

   445

   446

   447

   448

/**

   449

 * Event object that is signaled manually by Set() and reset automatically when thread passes Wait().

   450

 */

   451

struct AutoResetEvent_Win32 : public AutoResetEvent {

   452

	HANDLE m_handle;

   453

   454

	AutoResetEvent_Win32()

   455

	{

   456

		m_handle = ::CreateEvent(NULL, FALSE, FALSE, NULL);

   457

	}

   458

   459

	virtual ~AutoResetEvent_Win32()

   460

	{

   461

		::CloseHandle(m_handle);

   462

	}

   463

   464

	virtual void Set()

   465

	{

   466

		::SetEvent(m_handle);

   467

	}

   468

   469

	virtual void Wait()

   470

	{

   471

		::WaitForSingleObject(m_handle, INFINITE);

   472

	}

   473

};

   474

   475

/*static*/ AutoResetEvent* AutoResetEvent::New()

   476

{

   477

	return new AutoResetEvent_Win32();

   478

}

   479

   480

#endif