/* Threading for AtheOS.   Based on thread_beos.h. */ #include <atheos/threads.h>#include <atheos/semaphore.h>#include <atheos/atomic.h>#include <errno.h>#include <string.h> /* Missing decl from threads.h */extern int exit_thread(int);  /* Undefine FASTLOCK to play with simple semaphores. */#define FASTLOCK  #ifdef FASTLOCK /* Use an atomic counter and a semaphore for maximum speed. */typedef struct fastmutex {	sem_id sem;	atomic_t count;} fastmutex_t;  static int fastmutex_create(const char *name, fastmutex_t * mutex);static int fastmutex_destroy(fastmutex_t * mutex);static int fastmutex_lock(fastmutex_t * mutex);static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout);static int fastmutex_unlock(fastmutex_t * mutex);  static int fastmutex_create(const char *name, fastmutex_t * mutex){	mutex->count = 0;	mutex->sem = create_semaphore(name, 0, 0);	return (mutex->sem < 0) ? -1 : 0;}  static int fastmutex_destroy(fastmutex_t * mutex){	if (fastmutex_timedlock(mutex, 0) == 0 || errno == EWOULDBLOCK) {		return delete_semaphore(mutex->sem);	}	return 0;}  static int fastmutex_lock(fastmutex_t * mutex){	atomic_t prev = atomic_add(&mutex->count, 1);	if (prev > 0)		return lock_semaphore(mutex->sem);	return 0;}  static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout){	atomic_t prev = atomic_add(&mutex->count, 1);	if (prev > 0)		return lock_semaphore_x(mutex->sem, 1, 0, timeout);	return 0;}  static int fastmutex_unlock(fastmutex_t * mutex){	atomic_t prev = atomic_add(&mutex->count, -1);	if (prev > 1)		return unlock_semaphore(mutex->sem);	return 0;}  #endif				/* FASTLOCK */  /* * Initialization. * */static void PyThread__init_thread(void){	/* Do nothing. */	return;}  /* * Thread support. * */ static atomic_t thread_count = 0; long PyThread_start_new_thread(void (*func) (void *), void *arg){	status_t success = -1;	thread_id tid;	char name[OS_NAME_LENGTH];	atomic_t this_thread; 	dprintf(("PyThread_start_new_thread called\n")); 	this_thread = atomic_add(&thread_count, 1);	PyOS_snprintf(name, sizeof(name), "python thread (%d)", this_thread); 	tid = spawn_thread(name, func, NORMAL_PRIORITY, 0, arg);	if (tid < 0) {		dprintf(("PyThread_start_new_thread spawn_thread failed: %s\n", strerror(errno)));	} else {		success = resume_thread(tid);		if (success < 0) {			dprintf(("PyThread_start_new_thread resume_thread failed: %s\n", strerror(errno)));		}	} 	return (success < 0 ? -1 : tid);}  long PyThread_get_thread_ident(void){	return get_thread_id(NULL);}  static void do_PyThread_exit_thread(int no_cleanup){	dprintf(("PyThread_exit_thread called\n")); 	/* Thread-safe way to read a variable without a mutex: */	if (atomic_add(&thread_count, 0) == 0) {		/* No threads around, so exit main(). */		if (no_cleanup)			_exit(0);		else			exit(0);	} else {		/* We're a thread */		exit_thread(0);	}}  void PyThread_exit_thread(void){	do_PyThread_exit_thread(0);}  void PyThread__exit_thread(void){	do_PyThread_exit_thread(1);}  #ifndef NO_EXIT_PROGstatic void do_PyThread_exit_prog(int status, int no_cleanup){	dprintf(("PyThread_exit_prog(%d) called\n", status)); 	/* No need to do anything, the threads get torn down if main()exits. */	if (no_cleanup)		_exit(status);	else		exit(status);}  void PyThread_exit_prog(int status){	do_PyThread_exit_prog(status, 0);}  void PyThread__exit_prog(int status){	do_PyThread_exit_prog(status, 1);}#endif				/* NO_EXIT_PROG */  /* * Lock support. * */ static atomic_t lock_count = 0; PyThread_type_lock PyThread_allocate_lock(void){#ifdef FASTLOCK	fastmutex_t *lock;#else	sem_id sema;#endif	char name[OS_NAME_LENGTH];	atomic_t this_lock; 	dprintf(("PyThread_allocate_lock called\n")); #ifdef FASTLOCK	lock = (fastmutex_t *) malloc(sizeof(fastmutex_t));	if (lock == NULL) {		dprintf(("PyThread_allocate_lock failed: out of memory\n"));		return (PyThread_type_lock) NULL;	}#endif	this_lock = atomic_add(&lock_count, 1);	PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock); #ifdef FASTLOCK	if (fastmutex_create(name, lock) < 0) {		dprintf(("PyThread_allocate_lock failed: %s\n",			 strerror(errno)));		free(lock);		lock = NULL;	}	dprintf(("PyThread_allocate_lock()-> %p\n", lock));	return (PyThread_type_lock) lock;#else	sema = create_semaphore(name, 1, 0);	if (sema < 0) {		dprintf(("PyThread_allocate_lock failed: %s\n",			 strerror(errno)));		sema = 0;	}	dprintf(("PyThread_allocate_lock()-> %p\n", sema));	return (PyThread_type_lock) sema;#endif}  void PyThread_free_lock(PyThread_type_lock lock){	dprintf(("PyThread_free_lock(%p) called\n", lock)); #ifdef FASTLOCK	if (fastmutex_destroy((fastmutex_t *) lock) < 0) {		dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,			 strerror(errno)));	}	free(lock);#else	if (delete_semaphore((sem_id) lock) < 0) {		dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,			 strerror(errno)));	}#endif}  int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag){	int retval; 	dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock,		 waitflag)); #ifdef FASTLOCK	if (waitflag)		retval = fastmutex_lock((fastmutex_t *) lock);	else		retval = fastmutex_timedlock((fastmutex_t *) lock, 0);#else	if (waitflag)		retval = lock_semaphore((sem_id) lock);	else		retval = lock_semaphore_x((sem_id) lock, 1, 0, 0);#endif	if (retval < 0) {		dprintf(("PyThread_acquire_lock(%p, %d) failed: %s\n",			 lock, waitflag, strerror(errno)));	}	dprintf(("PyThread_acquire_lock(%p, %d)-> %d\n", lock, waitflag,		 retval));	return retval < 0 ? 0 : 1;}  void PyThread_release_lock(PyThread_type_lock lock){	dprintf(("PyThread_release_lock(%p) called\n", lock)); #ifdef FASTLOCK	if (fastmutex_unlock((fastmutex_t *) lock) < 0) {		dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,			 strerror(errno)));	}#else	if (unlock_semaphore((sem_id) lock) < 0) {		dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,			 strerror(errno)));	}#endif}