/* 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_PROG

static 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

}