mirror of
https://github.com/python/cpython.git
synced 2025-08-10 03:49:18 +00:00
Recorded merge of revisions 81029 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/trunk ........ r81029 | antoine.pitrou | 2010-05-09 16:46:46 +0200 (dim., 09 mai 2010) | 3 lines Untabify C files. Will watch buildbots. ........
This commit is contained in:
Antoine Pitrou
parent
ba32864b2d
commit
c7c96a90bc
321 changed files with 195492 additions and 195492 deletions
|
|
@ -19,8 +19,8 @@ extern int exit_thread(int);
|
|||
|
||||
/* Use an atomic counter and a semaphore for maximum speed. */
|
||||
typedef struct fastmutex {
|
||||
sem_id sem;
|
||||
atomic_t count;
|
||||
sem_id sem;
|
||||
atomic_t count;
|
||||
} fastmutex_t;
|
||||
|
||||
|
||||
|
|
@ -33,49 +33,49 @@ 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;
|
||||
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;
|
||||
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;
|
||||
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;
|
||||
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;
|
||||
atomic_t prev = atomic_add(&mutex->count, -1);
|
||||
if (prev > 1)
|
||||
return unlock_semaphore(mutex->sem);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
#endif /* FASTLOCK */
|
||||
#endif /* FASTLOCK */
|
||||
|
||||
|
||||
/*
|
||||
|
|
@ -84,8 +84,8 @@ static int fastmutex_unlock(fastmutex_t * mutex)
|
|||
*/
|
||||
static void PyThread__init_thread(void)
|
||||
{
|
||||
/* Do nothing. */
|
||||
return;
|
||||
/* Do nothing. */
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -98,90 +98,90 @@ 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;
|
||||
status_t success = -1;
|
||||
thread_id tid;
|
||||
char name[OS_NAME_LENGTH];
|
||||
atomic_t this_thread;
|
||||
|
||||
dprintf(("PyThread_start_new_thread called\n"));
|
||||
dprintf(("PyThread_start_new_thread called\n"));
|
||||
|
||||
this_thread = atomic_add(&thread_count, 1);
|
||||
PyOS_snprintf(name, sizeof(name), "python thread (%d)", this_thread);
|
||||
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)));
|
||||
}
|
||||
}
|
||||
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);
|
||||
return (success < 0 ? -1 : tid);
|
||||
}
|
||||
|
||||
|
||||
long PyThread_get_thread_ident(void)
|
||||
{
|
||||
return get_thread_id(NULL);
|
||||
return get_thread_id(NULL);
|
||||
}
|
||||
|
||||
|
||||
static void do_PyThread_exit_thread(int no_cleanup)
|
||||
{
|
||||
dprintf(("PyThread_exit_thread called\n"));
|
||||
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);
|
||||
}
|
||||
/* 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);
|
||||
do_PyThread_exit_thread(0);
|
||||
}
|
||||
|
||||
|
||||
void PyThread__exit_thread(void)
|
||||
{
|
||||
do_PyThread_exit_thread(1);
|
||||
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));
|
||||
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);
|
||||
/* 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);
|
||||
do_PyThread_exit_prog(status, 0);
|
||||
}
|
||||
|
||||
|
||||
void PyThread__exit_prog(int status)
|
||||
{
|
||||
do_PyThread_exit_prog(status, 1);
|
||||
do_PyThread_exit_prog(status, 1);
|
||||
}
|
||||
#endif /* NO_EXIT_PROG */
|
||||
#endif /* NO_EXIT_PROG */
|
||||
|
||||
|
||||
/*
|
||||
|
|
@ -194,107 +194,107 @@ static atomic_t lock_count = 0;
|
|||
PyThread_type_lock PyThread_allocate_lock(void)
|
||||
{
|
||||
#ifdef FASTLOCK
|
||||
fastmutex_t *lock;
|
||||
fastmutex_t *lock;
|
||||
#else
|
||||
sem_id sema;
|
||||
sem_id sema;
|
||||
#endif
|
||||
char name[OS_NAME_LENGTH];
|
||||
atomic_t this_lock;
|
||||
char name[OS_NAME_LENGTH];
|
||||
atomic_t this_lock;
|
||||
|
||||
dprintf(("PyThread_allocate_lock called\n"));
|
||||
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;
|
||||
}
|
||||
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);
|
||||
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;
|
||||
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;
|
||||
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));
|
||||
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);
|
||||
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)));
|
||||
}
|
||||
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;
|
||||
int retval;
|
||||
|
||||
dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock,
|
||||
waitflag));
|
||||
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);
|
||||
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);
|
||||
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;
|
||||
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));
|
||||
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)));
|
||||
}
|
||||
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)));
|
||||
}
|
||||
if (unlock_semaphore((sem_id) lock) < 0) {
|
||||
dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,
|
||||
strerror(errno)));
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue