1

/* $Id$ */

     2

     3

/** @file thread_pthread.cpp POSIX pthread 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 <pthread.h>

    11

#include <semaphore.h>

    12

#include <unistd.h>

    13

    14

struct OTTDThread {

    15

	pthread_t thread;

    16

};

    17

    18

OTTDThread *OTTDCreateThread(OTTDThreadFunc function, void *arg)

    19

{

    20

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

    21

    22

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

    23

		return t;

    24

	} else {

    25

		free(t);

    26

		return NULL;

    27

	}

    28

}

    29

    30

void *OTTDJoinThread(OTTDThread *t)

    31

{

    33

    34

	if (t == NULL) return NULL;

    35

    36

	pthread_join(t->thread, &ret);

    37

	free(t);

    38

	return ret;

    39

}

    40

    41

void OTTDExitThread()

    42

{

    43

	pthread_exit(NULL);

    44

}

    45

    46

    47

/**

    48

 * POSIX pthread version for ThreadObject.

    49

 */

    50

class ThreadObject_pthread : public ThreadObject {

    51

private:

    52

	pthread_t m_thr;             ///< System thread identifier.

    53

	OTTDThreadFunc m_proc;       ///< External thread procedure.

    54

	void     *m_param;           ///< Parameter for the external thread procedure.

    55

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

    56

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

    57

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

    58

    59

public:

    60

	/**

    61

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

    62

	 */

    63

	ThreadObject_pthread(OTTDThreadFunc proc, void *param) :

    64

		m_thr(0),

    65

		m_proc(proc),

    66

		m_param(param),

    67

		m_attached(false)

    68

	{

    69

		sem_init(&m_sem_start, 0, 0);

    70

		sem_init(&m_sem_stop, 0, 0);

    71

    72

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

    73

		sem_post(&m_sem_start);

    74

	}

    75

    76

	/**

    77

	 * Create a pthread and attach current thread to it.

    78

	 */

    79

	ThreadObject_pthread() :

    80

		m_thr(0),

    81

		m_proc(NULL),

    82

		m_param(0),

    83

		m_attached(true)

    84

	{

    85

		sem_init(&m_sem_start, 0, 0);

    86

		sem_init(&m_sem_stop, 0, 0);

    87

    88

		m_thr = pthread_self();

    89

	}

    90

    91

	/* virtual */ ~ThreadObject_pthread()

    92

	{

    93

		sem_destroy(&m_sem_stop);

    94

		sem_destroy(&m_sem_start);

    95

	};

    96

    97

	/* virtual */ bool IsRunning()

    98

	{

    99

		return m_thr != 0;

   100

	}

   101

   102

	/* virtual */ bool WaitForStop()

   103

	{

   104

		/* You can't wait on yourself */

   105

		assert(!IsCurrent());

   106

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

   107

		if (!IsRunning()) return true;

   108

   109

		int ret = sem_wait(&m_sem_stop);

   110

		if (ret == 0) {

   111

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

   112

			sem_post(&m_sem_stop);

   113

			return true;

   114

		}

   115

		return false;

   116

	}

   117

   118

	/* virtual */ bool Exit()

   119

	{

   120

		/* You can only exit yourself */

   121

		assert(IsCurrent());

   122

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

   123

		if (!IsRunning()) return false;

   124

   125

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

   126

		throw 0;

   127

	}

   128

   129

	/* virtual */ void Join()

   130

	{

   131

		/* You cannot join yourself */

   132

		assert(!IsCurrent());

   133

   134

		pthread_join(m_thr, NULL);

   135

		m_thr = 0;

   136

	}

   137

   138

	/* virtual */ bool IsCurrent()

   139

	{

   140

		return pthread_self() == m_thr;

   141

	}

   142

   143

	/* virtual */ uint GetId()

   144

	{

   145

		return (uint)m_thr;

   146

	}

   147

   148

private:

   149

	/**

   150

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

   151

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

   152

	 */

   153

	static void *stThreadProc(void *thr)

   154

	{

   155

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

   156

	}

   157

   158

	/**

   159

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

   160

	 *  function of the creator of the thread.

   161

	 */

   162

	void *ThreadProc()

   163

	{

   164

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

   165

		sem_wait(&m_sem_start);

   166

   167

		/* Call the proc of the creator to continue this thread */

   168

		try {

   169

			m_proc(m_param);

   170

		} catch (...) {

   171

		}

   172

   173

		/* Notify threads waiting for our completion */

   174

		sem_post(&m_sem_stop);

   175

   176

		return NULL;

   177

	}

   178

};

   179

   180

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

   181

{

   182

	return new ThreadObject_pthread(proc, param);

   183

}

   184

   185

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

   186

{

   187

	return new ThreadObject_pthread();

   188

}

   189

   190

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

   191

{

   192

	return (uint)pthread_self();

   193

}

   194

   195

   196

/**

   197

 * POSIX pthread version of ThreadSemaphore.

   198

 */

   199

class ThreadSemaphore_pthread : public ThreadSemaphore {

   200

private:

   201

	sem_t m_sem;

   202

   203

public:

   204

	ThreadSemaphore_pthread()

   205

	{

   206

		sem_init(&m_sem, 0, 0);

   207

	}

   208

   209

	/* virtual */ ~ThreadSemaphore_pthread()

   210

	{

   211

		sem_destroy(&m_sem);

   212

	}

   213

   214

	/* virtual */ void Set()

   215

	{

   216

		int val = 0;

   217

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

   218

	}

   219

   220

	/* virtual */ void Wait()

   221

	{

   222

		sem_wait(&m_sem);

   223

	}

   224

};

   225

   226

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

   227

{

   228

	return new ThreadSemaphore_pthread();

   229

}