src/tools/thread.cc

/*
 *      HT Editor
 *      thread.cc
 *
 *      Copyright (C) 2003 Sebastian Biallas (sb@biallas.net)
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2 as
 *      published by the Free Software Foundation.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <cstdio>
#include <cstdlib>

#include "debug.h"
#include "except.h"
#include "thread.h"

static void *start_thread_routine(void *t)
{
        Thread *thread = ((Thread *)t);
        thread->setState(threadRunning);
        void *ret = thread->run();
        if (thread->getState() == threadRunning) {
                /*
                 *      Thread reached end of run(), and most likely
                 *      didn't call terminate(), so we do here
                 */
                 thread->terminate(ret);
        }
        return ret;
}

Thread::Thread()
{
        mThreadValid = false;
        mState = threadInited;
        mSem = new Semaphore();
}

Thread::~Thread()
{
        if (mState == threadStarting || mState == threadRunning)  {
                // in a perfect world, we'd throw an exception here
                fprintf(stderr, "Attempt to kill running thread!\n");
                // but world isn't perfect
                exit(1);
        }
        if (mThreadValid) {
                sys_destroy_thread(mThread);
        }
}

void Thread::start(void *param)
{
        setState(threadStarting);
        mThreadValid = true;
        sys_create_thread(&mThread, 0, start_thread_routine, this);
}

ThreadState Thread::getState()
{
        return mState;
}

void Thread::setState(ThreadState state)
{
        mSem->lock();
        mState = state;
        mSem->signalAll();
        mSem->unlock();
}

void *Thread::waitForExit()
{
        mSem->lock();
        while (mState == threadStarting) {
                mSem->wait();
        }
        mSem->unlock();
        mSem->lock();
        while (mState == threadRunning) {
                mSem->wait();
        }
        mSem->unlock();
        return NULL;
}

void Thread::waitForRunning()
{
        mSem->lock();
        while (mState == threadStarting) {
                mSem->wait();
        }
        mSem->unlock();
}

void Thread::terminate(void *ret)
{
        if (mState == threadRunning) {
                ASSERT(mThreadValid);
                setState(threadFinished);
                sys_exit_thread(ret);
        } else {
                throw MsgException("Arrrrrrg. Please read the docu. You musn't call terminate() from outside the thread.");
        }
}

/*
 *
 */
ThreadFunction::ThreadFunction(sys_thread_function f, void *aParam)
        :Thread()
{
        mFunc = f;
        mParam = aParam;
}

void *ThreadFunction::run()
{
        terminate(mFunc(mParam));
        // terminate does not return
        return NULL;
}

/*
 *
 */
Mutex::Mutex()
{
        sys_create_mutex(&mutex);
}

Mutex::~Mutex()
{
        sys_destroy_mutex(mutex);
}

void Mutex::lock()
{
        sys_lock_mutex(mutex);
}

void Mutex::unlock()
{
        sys_unlock_mutex(mutex);
}

int Mutex::trylock()
{
        return sys_trylock_mutex(mutex);
}

/*
 *
 */

Semaphore::Semaphore()
{
        sys_create_semaphore(&sem);
}

Semaphore::~Semaphore()
{
        sys_destroy_semaphore(sem);
}

void Semaphore::signal()
{
        sys_signal_semaphore(sem);
}

void Semaphore::signalAll()
{
        sys_signal_all_semaphore(sem);
}

void Semaphore::wait()
{
        sys_wait_semaphore(sem);
}

void Semaphore::lock()
{
        sys_lock_semaphore(sem);
}

void Semaphore::unlock()
{
        sys_unlock_semaphore(sem);
}

1	dpavlin	1	/*
2			* HT Editor
3			* thread.cc
4			*
5			* Copyright (C) 2003 Sebastian Biallas (sb@biallas.net)
6			*
7			* This program is free software; you can redistribute it and/or modify
8			* it under the terms of the GNU General Public License version 2 as
9			* published by the Free Software Foundation.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with this program; if not, write to the Free Software
18			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19			*/
20
21			#include <cstdio>
22			#include <cstdlib>
23
24			#include "debug.h"
25			#include "except.h"
26			#include "thread.h"
27
28			static void start_thread_routine(void t)
29			{
30			Thread thread = ((Thread )t);
31			thread->setState(threadRunning);
32			void *ret = thread->run();
33			if (thread->getState() == threadRunning) {
34			/*
35			* Thread reached end of run(), and most likely
36			* didn't call terminate(), so we do here
37			*/
38			thread->terminate(ret);
39			}
40			return ret;
41			}
42
43			Thread::Thread()
44			{
45			mThreadValid = false;
46			mState = threadInited;
47			mSem = new Semaphore();
48			}
49
50			Thread::~Thread()
51			{
52			if (mState == threadStarting \|\| mState == threadRunning) {
53			// in a perfect world, we'd throw an exception here
54			fprintf(stderr, "Attempt to kill running thread!\n");
55			// but world isn't perfect
56			exit(1);
57			}
58			if (mThreadValid) {
59			sys_destroy_thread(mThread);
60			}
61			}
62
63			void Thread::start(void *param)
64			{
65			setState(threadStarting);
66			mThreadValid = true;
67			sys_create_thread(&mThread, 0, start_thread_routine, this);
68			}
69
70			ThreadState Thread::getState()
71			{
72			return mState;
73			}
74
75			void Thread::setState(ThreadState state)
76			{
77			mSem->lock();
78			mState = state;
79			mSem->signalAll();
80			mSem->unlock();
81			}
82
83			void *Thread::waitForExit()
84			{
85			mSem->lock();
86			while (mState == threadStarting) {
87			mSem->wait();
88			}
89			mSem->unlock();
90			mSem->lock();
91			while (mState == threadRunning) {
92			mSem->wait();
93			}
94			mSem->unlock();
95			return NULL;
96			}
97
98			void Thread::waitForRunning()
99			{
100			mSem->lock();
101			while (mState == threadStarting) {
102			mSem->wait();
103			}
104			mSem->unlock();
105			}
106
107			void Thread::terminate(void *ret)
108			{
109			if (mState == threadRunning) {
110			ASSERT(mThreadValid);
111			setState(threadFinished);
112			sys_exit_thread(ret);
113			} else {
114			throw MsgException("Arrrrrrg. Please read the docu. You musn't call terminate() from outside the thread.");
115			}
116			}
117
118			/*
119			*
120			*/
121			ThreadFunction::ThreadFunction(sys_thread_function f, void *aParam)
122			:Thread()
123			{
124			mFunc = f;
125			mParam = aParam;
126			}
127
128			void *ThreadFunction::run()
129			{
130			terminate(mFunc(mParam));
131			// terminate does not return
132			return NULL;
133			}
134
135			/*
136			*
137			*/
138			Mutex::Mutex()
139			{
140			sys_create_mutex(&mutex);
141			}
142
143			Mutex::~Mutex()
144			{
145			sys_destroy_mutex(mutex);
146			}
147
148			void Mutex::lock()
149			{
150			sys_lock_mutex(mutex);
151			}
152
153			void Mutex::unlock()
154			{
155			sys_unlock_mutex(mutex);
156			}
157
158			int Mutex::trylock()
159			{
160			return sys_trylock_mutex(mutex);
161			}
162
163			/*
164			*
165			*/
166
167			Semaphore::Semaphore()
168			{
169			sys_create_semaphore(&sem);
170			}
171
172			Semaphore::~Semaphore()
173			{
174			sys_destroy_semaphore(sem);
175			}
176
177			void Semaphore::signal()
178			{
179			sys_signal_semaphore(sem);
180			}
181
182			void Semaphore::signalAll()
183			{
184			sys_signal_all_semaphore(sem);
185			}
186
187			void Semaphore::wait()
188			{
189			sys_wait_semaphore(sem);
190			}
191
192			void Semaphore::lock()
193			{
194			sys_lock_semaphore(sem);
195			}
196
197			void Semaphore::unlock()
198			{
199			sys_unlock_semaphore(sem);
200			}
201