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

/**

    15

 * POSIX pthread version for ThreadObject.

    16

 */

    17

class ThreadObject_pthread : public ThreadObject {

    18

private:

    19

	pthread_t m_thr;             ///< System thread identifier.

    20

	OTTDThreadFunc m_proc;       ///< External thread procedure.

    21

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

    22

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

    23

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

    24

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

    25

    26

public:

    27

	/**

    28

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

    29

	 */

    30

	ThreadObject_pthread(OTTDThreadFunc proc, void *param) :

    31

		m_thr(0),

    32

		m_proc(proc),

    33

		m_param(param),

    34

		m_attached(false)

    35

	{

    36

		sem_init(&m_sem_start, 0, 0);

    37

		sem_init(&m_sem_stop, 0, 0);

    38

    39

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

    40

		sem_post(&m_sem_start);

    41

	}

    42

    43

	/**

    44

	 * Create a pthread and attach current thread to it.

    45

	 */

    46

	ThreadObject_pthread() :

    47

		m_thr(0),

    48

		m_proc(NULL),

    49

		m_param(0),

    50

		m_attached(true)

    51

	{

    52

		sem_init(&m_sem_start, 0, 0);

    53

		sem_init(&m_sem_stop, 0, 0);

    54

    55

		m_thr = pthread_self();

    56

	}

    57

    58

	/* virtual */ ~ThreadObject_pthread()

    59

	{

    60

		sem_destroy(&m_sem_stop);

    61

		sem_destroy(&m_sem_start);

    62

	};

    63

    64

	/* virtual */ bool IsRunning()

    65

	{

    66

		int sval;

    67

		sem_getvalue(&m_sem_stop, &sval);

    68

		return sval == 0;

    69

	}

    70

    71

	/* virtual */ bool WaitForStop()

    72

	{

    73

		/* You can't wait on yourself */

    74

		assert(!IsCurrent());

    75

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

    76

		if (!IsRunning()) return true;

    77

    78

		int ret = sem_wait(&m_sem_stop);

    79

		if (ret == 0) {

    80

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

    81

			sem_post(&m_sem_stop);

    82

			return true;

    83

		}

    84

		return false;

    85

	}

    86

    87

	/* virtual */ bool Exit()

    88

	{

    89

		/* You can only exit yourself */

    90

		assert(IsCurrent());

    91

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

    92

		if (!IsRunning()) return false;

    93

    94

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

    95

		throw 0;

    96

	}

    97

    98

	/* virtual */ void Join()

    99

	{

   100

		/* You cannot join yourself */

   101

		assert(!IsCurrent());

   102

   103

		pthread_join(m_thr, NULL);

   104

		m_thr = 0;

   105

	}

   106

   107

	/* virtual */ bool IsCurrent()

   108

	{

   109

		return pthread_self() == m_thr;

   110

	}

   111

   112

	/* virtual */ uint GetId()

   113

	{

   114

		return (uint)m_thr;

   115

	}

   116

   117

private:

   118

	/**

   119

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

   120

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

   121

	 */

   122

	static void *stThreadProc(void *thr)

   123

	{

   124

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

   125

		pthread_exit(NULL);

   126

	}

   127

   128

	/**

   129

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

   130

	 *  function of the creator of the thread.

   131

	 */

   132

	void ThreadProc()

   133

	{

   134

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

   135

		sem_wait(&m_sem_start);

   136

   137

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

   138

		try {

   139

			m_proc(m_param);

   140

		} catch (...) {

   141

		}

   142

   143

		/* Notify threads waiting for our completion */

   144

		sem_post(&m_sem_stop);

   145

	}

   146

};

   147

   148

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

   149

{

   150

	return new ThreadObject_pthread(proc, param);

   151

}

   152

   153

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

   154

{

   155

	return new ThreadObject_pthread();

   156

}

   157

   158

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

   159

{

   160

	return (uint)pthread_self();

   161

}

   162

   163

   164

/**

   165

 * POSIX pthread version of ThreadSemaphore.

   166

 */

   167

class ThreadSemaphore_pthread : public ThreadSemaphore {

   168

private:

   169

	sem_t m_sem;

   170

   171

public:

   172

	ThreadSemaphore_pthread()

   173

	{

   174

		sem_init(&m_sem, 0, 0);

   175

	}

   176

   177

	/* virtual */ ~ThreadSemaphore_pthread()

   178

	{

   179

		sem_destroy(&m_sem);

   180

	}

   181

   182

	/* virtual */ void Set()

   183

	{

   184

		int val = 0;

   185

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

   186

	}

   187

   188

	/* virtual */ void Wait()

   189

	{

   190

		sem_wait(&m_sem);

   191

	}

   192

};

   193

   194

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

   195

{

   196

	return new ThreadSemaphore_pthread();

   197

}