1

/* $Id$ */

     2

     3

/** @file thread_win32.cpp Win32 thread 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 <windows.h>

    11

#include <process.h>

    12

    13

struct OTTDThread {

    14

	HANDLE thread;

    15

	uint   thread_id;

    16

	OTTDThreadFunc func;

    17

	void *arg;

    18

	void *ret;

    19

};

    20

    21

static unsigned WINAPI Proxy(LPVOID arg)

    22

{

    23

	OTTDThread *t = (OTTDThread *)arg;

    24

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

    25

	return 0;

    26

}

    27

    28

OTTDThread *OTTDCreateThread(OTTDThreadFunc function, void *arg)

    29

{

    30

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

    31

    32

	if (t == NULL) return NULL;

    33

    34

	t->func = function;

    35

	t->arg  = arg;

    36

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

    37

    38

	if (t->thread != NULL) {

    39

		return t;

    40

	} else {

    41

		free(t);

    42

		return NULL;

    43

	}

    44

}

    45

    46

void *OTTDJoinThread(OTTDThread *t)

    47

{

    48

	void *ret;

    49

    50

	if (t == NULL) return NULL;

    51

    52

	WaitForSingleObject(t->thread, INFINITE);

    53

	CloseHandle(t->thread);

    54

	ret = t->ret;

    55

	free(t);

    56

	return ret;

    57

}

    58

    59

void OTTDExitThread()

    60

{

    61

	_endthreadex(0);

    62

}

    63

    64

/**

    65

 * Win32 thread version for ThreadObject.

    66

 */

    67

class ThreadObject_Win32 : public ThreadObject {

    68

private:

    69

	uint     m_id_thr;

    70

	HANDLE   m_h_thr;

    71

	OTTDThreadFunc m_proc;

    72

	void     *m_param;

    73

	bool     m_attached;

    74

    75

public:

    76

	/**

    77

	 * Create a win32 thread and start it, calling proc(param).

    78

	 */

    79

	ThreadObject_Win32(OTTDThreadFunc proc, void *param) :

    80

		m_id_thr(0),

    81

		m_h_thr(NULL),

    82

		m_proc(proc),

    83

		m_param(param),

    84

		m_attached(false)

    85

	{

    86

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

    87

		if (m_h_thr == NULL) return;

    88

		ResumeThread(m_h_thr);

    89

	}

    90

    91

	/**

    92

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

    93

	 */

    94

	ThreadObject_Win32() :

    95

		m_id_thr(0),

    96

		m_h_thr(NULL),

    97

		m_proc(NULL),

    98

		m_param(NULL),

    99

		m_attached(false)

   100

	{

   101

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

   102

		if (!ret) return;

   103

		m_id_thr = GetCurrentThreadId();

   104

	}

   105

   106

	/* virtual */ ~ThreadObject_Win32()

   107

	{

   108

		if (m_h_thr != NULL) {

   109

			CloseHandle(m_h_thr);

   110

			m_h_thr = NULL;

   111

		}

   112

	}

   113

   114

	/* virtual */ bool IsRunning()

   115

	{

   116

		if (m_h_thr == NULL) return false;

   117

		DWORD exit_code = 0;

   118

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

   119

		return (exit_code == STILL_ACTIVE);

   120

	}

   121

   122

	/* virtual */ bool WaitForStop()

   123

	{

   124

		/* You can't wait on yourself */

   125

		assert(!IsCurrent());

   126

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

   127

		if (!IsRunning()) return true;

   128

   129

		DWORD res = WaitForSingleObject(m_h_thr, INFINITE);

   130

		return res == WAIT_OBJECT_0;

   131

	}

   132

   152

	/* virtual */ bool IsCurrent()

   153

	{

   154

		DWORD id_cur = GetCurrentThreadId();

   155

		return id_cur == m_id_thr;

   156

	}

   157

   158

	/* virtual */ uint GetId()

   159

	{

   160

		return m_id_thr;

   161

	}

   162

   163

private:

   164

	/**

   165

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

   166

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

   167

	 */

   168

	static uint CALLBACK stThreadProc(void *thr)

   169

	{

   171

	}

   172

   173

	/**

   174

	 * A new thread is created, and this function is called. Call the custom

   175

	 *  function of the creator of the thread.

   176

	 */

   177

	uint ThreadProc()

   178

	{

   179

		try {

   180

			m_proc(m_param);

   181

		} catch (...) {

   182

		}

   183

   184

		return 0;

   185

	}

   186

};

   187

   188

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

   189

{

   190

	return new ThreadObject_Win32(proc, param);

   191

}

   192

   193

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

   194

{

   195

	return new ThreadObject_Win32();

   196

}

   197

   198

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

   199

{

   200

	return GetCurrentThreadId();

   201

}

   202

   203

   204

/**

   205

 * Win32 thread version of ThreadSemaphore.

   206

 */

   207

class ThreadSemaphore_Win32 : public ThreadSemaphore {

   208

private:

   209

	HANDLE m_handle;

   210

   211

public:

   212

	ThreadSemaphore_Win32()

   213

	{

   214

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

   215

	}

   216

   217

	/* virtual */ ~ThreadSemaphore_Win32()

   218

	{

   219

		::CloseHandle(m_handle);

   220

	}

   221

   222

	/* virtual */ void Set()

   223

	{

   224

		::SetEvent(m_handle);

   225

	}

   226

   227

	/* virtual */ void Wait()

   228

	{

   229

		::WaitForSingleObject(m_handle, INFINITE);

   230

	}

   231

};

   232

   233

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

   234

{

   235

	return new ThreadSemaphore_Win32();

   236

}