PageRenderTime 84ms CodeModel.GetById 41ms app.highlight 18ms RepoModel.GetById 22ms app.codeStats 0ms

/Python/thread_atheos.h

http://unladen-swallow.googlecode.com/
C++ Header | 300 lines | 214 code | 64 blank | 22 comment | 26 complexity | c60a78e4a2310f9a8b25ef43f240617a MD5 | raw file
  1/* Threading for AtheOS.
  2   Based on thread_beos.h. */
  3
  4#include <atheos/threads.h>
  5#include <atheos/semaphore.h>
  6#include <atheos/atomic.h>
  7#include <errno.h>
  8#include <string.h>
  9
 10/* Missing decl from threads.h */
 11extern int exit_thread(int);
 12
 13
 14/* Undefine FASTLOCK to play with simple semaphores. */
 15#define FASTLOCK
 16
 17
 18#ifdef FASTLOCK
 19
 20/* Use an atomic counter and a semaphore for maximum speed. */
 21typedef struct fastmutex {
 22	sem_id sem;
 23	atomic_t count;
 24} fastmutex_t;
 25
 26
 27static int fastmutex_create(const char *name, fastmutex_t * mutex);
 28static int fastmutex_destroy(fastmutex_t * mutex);
 29static int fastmutex_lock(fastmutex_t * mutex);
 30static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout);
 31static int fastmutex_unlock(fastmutex_t * mutex);
 32
 33
 34static int fastmutex_create(const char *name, fastmutex_t * mutex)
 35{
 36	mutex->count = 0;
 37	mutex->sem = create_semaphore(name, 0, 0);
 38	return (mutex->sem < 0) ? -1 : 0;
 39}
 40
 41
 42static int fastmutex_destroy(fastmutex_t * mutex)
 43{
 44	if (fastmutex_timedlock(mutex, 0) == 0 || errno == EWOULDBLOCK) {
 45		return delete_semaphore(mutex->sem);
 46	}
 47	return 0;
 48}
 49
 50
 51static int fastmutex_lock(fastmutex_t * mutex)
 52{
 53	atomic_t prev = atomic_add(&mutex->count, 1);
 54	if (prev > 0)
 55		return lock_semaphore(mutex->sem);
 56	return 0;
 57}
 58
 59
 60static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout)
 61{
 62	atomic_t prev = atomic_add(&mutex->count, 1);
 63	if (prev > 0)
 64		return lock_semaphore_x(mutex->sem, 1, 0, timeout);
 65	return 0;
 66}
 67
 68
 69static int fastmutex_unlock(fastmutex_t * mutex)
 70{
 71	atomic_t prev = atomic_add(&mutex->count, -1);
 72	if (prev > 1)
 73		return unlock_semaphore(mutex->sem);
 74	return 0;
 75}
 76
 77
 78#endif				/* FASTLOCK */
 79
 80
 81/*
 82 * Initialization.
 83 *
 84 */
 85static void PyThread__init_thread(void)
 86{
 87	/* Do nothing. */
 88	return;
 89}
 90
 91
 92/*
 93 * Thread support.
 94 *
 95 */
 96
 97static atomic_t thread_count = 0;
 98
 99long PyThread_start_new_thread(void (*func) (void *), void *arg)
100{
101	status_t success = -1;
102	thread_id tid;
103	char name[OS_NAME_LENGTH];
104	atomic_t this_thread;
105
106	dprintf(("PyThread_start_new_thread called\n"));
107
108	this_thread = atomic_add(&thread_count, 1);
109	PyOS_snprintf(name, sizeof(name), "python thread (%d)", this_thread);
110
111	tid = spawn_thread(name, func, NORMAL_PRIORITY, 0, arg);
112	if (tid < 0) {
113		dprintf(("PyThread_start_new_thread spawn_thread failed: %s\n", strerror(errno)));
114	} else {
115		success = resume_thread(tid);
116		if (success < 0) {
117			dprintf(("PyThread_start_new_thread resume_thread failed: %s\n", strerror(errno)));
118		}
119	}
120
121	return (success < 0 ? -1 : tid);
122}
123
124
125long PyThread_get_thread_ident(void)
126{
127	return get_thread_id(NULL);
128}
129
130
131static void do_PyThread_exit_thread(int no_cleanup)
132{
133	dprintf(("PyThread_exit_thread called\n"));
134
135	/* Thread-safe way to read a variable without a mutex: */
136	if (atomic_add(&thread_count, 0) == 0) {
137		/* No threads around, so exit main(). */
138		if (no_cleanup)
139			_exit(0);
140		else
141			exit(0);
142	} else {
143		/* We're a thread */
144		exit_thread(0);
145	}
146}
147
148
149void PyThread_exit_thread(void)
150{
151	do_PyThread_exit_thread(0);
152}
153
154
155void PyThread__exit_thread(void)
156{
157	do_PyThread_exit_thread(1);
158}
159
160
161#ifndef NO_EXIT_PROG
162static void do_PyThread_exit_prog(int status, int no_cleanup)
163{
164	dprintf(("PyThread_exit_prog(%d) called\n", status));
165
166	/* No need to do anything, the threads get torn down if main()exits. */
167	if (no_cleanup)
168		_exit(status);
169	else
170		exit(status);
171}
172
173
174void PyThread_exit_prog(int status)
175{
176	do_PyThread_exit_prog(status, 0);
177}
178
179
180void PyThread__exit_prog(int status)
181{
182	do_PyThread_exit_prog(status, 1);
183}
184#endif				/* NO_EXIT_PROG */
185
186
187/*
188 * Lock support.
189 *
190 */
191
192static atomic_t lock_count = 0;
193
194PyThread_type_lock PyThread_allocate_lock(void)
195{
196#ifdef FASTLOCK
197	fastmutex_t *lock;
198#else
199	sem_id sema;
200#endif
201	char name[OS_NAME_LENGTH];
202	atomic_t this_lock;
203
204	dprintf(("PyThread_allocate_lock called\n"));
205
206#ifdef FASTLOCK
207	lock = (fastmutex_t *) malloc(sizeof(fastmutex_t));
208	if (lock == NULL) {
209		dprintf(("PyThread_allocate_lock failed: out of memory\n"));
210		return (PyThread_type_lock) NULL;
211	}
212#endif
213	this_lock = atomic_add(&lock_count, 1);
214	PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);
215
216#ifdef FASTLOCK
217	if (fastmutex_create(name, lock) < 0) {
218		dprintf(("PyThread_allocate_lock failed: %s\n",
219			 strerror(errno)));
220		free(lock);
221		lock = NULL;
222	}
223	dprintf(("PyThread_allocate_lock()-> %p\n", lock));
224	return (PyThread_type_lock) lock;
225#else
226	sema = create_semaphore(name, 1, 0);
227	if (sema < 0) {
228		dprintf(("PyThread_allocate_lock failed: %s\n",
229			 strerror(errno)));
230		sema = 0;
231	}
232	dprintf(("PyThread_allocate_lock()-> %p\n", sema));
233	return (PyThread_type_lock) sema;
234#endif
235}
236
237
238void PyThread_free_lock(PyThread_type_lock lock)
239{
240	dprintf(("PyThread_free_lock(%p) called\n", lock));
241
242#ifdef FASTLOCK
243	if (fastmutex_destroy((fastmutex_t *) lock) < 0) {
244		dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,
245			 strerror(errno)));
246	}
247	free(lock);
248#else
249	if (delete_semaphore((sem_id) lock) < 0) {
250		dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,
251			 strerror(errno)));
252	}
253#endif
254}
255
256
257int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
258{
259	int retval;
260
261	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock,
262		 waitflag));
263
264#ifdef FASTLOCK
265	if (waitflag)
266		retval = fastmutex_lock((fastmutex_t *) lock);
267	else
268		retval = fastmutex_timedlock((fastmutex_t *) lock, 0);
269#else
270	if (waitflag)
271		retval = lock_semaphore((sem_id) lock);
272	else
273		retval = lock_semaphore_x((sem_id) lock, 1, 0, 0);
274#endif
275	if (retval < 0) {
276		dprintf(("PyThread_acquire_lock(%p, %d) failed: %s\n",
277			 lock, waitflag, strerror(errno)));
278	}
279	dprintf(("PyThread_acquire_lock(%p, %d)-> %d\n", lock, waitflag,
280		 retval));
281	return retval < 0 ? 0 : 1;
282}
283
284
285void PyThread_release_lock(PyThread_type_lock lock)
286{
287	dprintf(("PyThread_release_lock(%p) called\n", lock));
288
289#ifdef FASTLOCK
290	if (fastmutex_unlock((fastmutex_t *) lock) < 0) {
291		dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
292			 strerror(errno)));
293	}
294#else
295	if (unlock_semaphore((sem_id) lock) < 0) {
296		dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
297			 strerror(errno)));
298	}
299#endif
300}