[Python-Dev] POSIX thread code (original) (raw)

Gerald S. Williams gsw@agere.com
Wed, 27 Feb 2002 17:54:32 -0500

This is a multi-part message in MIME format.

------=_NextPart_000_0023_01C1BFB7.CF9678F0 Content-Type: text/plain; charset="iso-8859-1" Content-Transfer-Encoding: 7bit

I recently came up with a fix for thread support in Python under Cygwin. Jason Tishler and Norman Vine are looking it over, but I'm pretty sure something similar should be used for the Cygwin Python port.

This is easily done--simply add a few lines to thread.c and create a new thread_cygwin.h (context diff and new file both provided).

But there is a larger issue:

The thread interface code in thread_pthread.h uses mutexes and condition variables to emulate semaphores, which are then used to provide Python "lock" and "sema" services.

I know this is a common practice since those two thread synchronization primitives are defined in "pthread.h". But it comes with quite a bit of overhead. (And in the case of Cygwin causes race conditions, but that's another matter.)

POSIX does define semaphores, though. (In fact, it's in the standard just before Mutexes and Condition Variables.) According to POSIX, they are found in <semaphore.h> and _POSIX_SEMAPHORES should be defined if they work as POSIX expects.

If they are available, it seems like providing direct semaphore services would be preferable to emulating them using condition variables and mutexes.

thread_posix.h.diff-c is a context diff that can be used to convert thread_pthread.h into a more general POSIX version that will use semaphores if available.

thread_cygwin.h would no longer be needed then, since all it does is uses POSIX semaphores directly rather than mutexes/condition vars. Changing the interface to POSIX threads should bring a performance improvement to any POSIX platform that supports semaphores directly.

Does this sound like a good idea? Should I create a more thorough set of patch files and submit them?

(I haven't been accepted to the python-dev list yet, so please CC me. Thanks.)

-Jerry

-O Gerald S. Williams, 22Y-103GA : mailto:gsw@agere.com O- -O AGERE SYSTEMS, 555 UNION BLVD : office:610-712-8661 O- -O ALLENTOWN, PA, USA 18109-3286 : mobile:908-672-7592 O-

------=_NextPart_000_0023_01C1BFB7.CF9678F0 Content-Type: application/octet-stream; name="thread.c.diff-c" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="thread.c.diff-c"

*** thread.c Tue Oct 16 17:13:49 2001 --- thread.c.new Tue Feb 26 07:49:13 2002

*** 113,118 **** --- 113,123 ---- #include "thread_pth.h" #endif

------=_NextPart_000_0023_01C1BFB7.CF9678F0 Content-Type: application/octet-stream; name="thread_cygwin.h" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="thread_cygwin.h"

/* Posix threads interface */

/*

#include <stdlib.h> #include <string.h> #include <pthread.h> #include <signal.h> #include <semaphore.h>

/* try to determine what version of the Pthread Standard is installed.

#if defined(__ultrix) && defined(__mips) && defined(DECTHREADS) /* DECTHREADS is defined in cma.h which is included by pthread.h */

define PY_PTHREAD_D4

#elif defined(osf) && defined (__alpha) /* DECTHREADS is defined in cma.h which is included by pthread.h */

if !defined(_PTHREAD_ENV_ALPHA) || defined(_PTHREAD_USE_D4) || defined(PTHREAD_USE_D4)

define PY_PTHREAD_D4

else

define PY_PTHREAD_STD

endif

#elif defined(_AIX) /* SCHED_BG_NP is defined if using AIX DCE pthreads

if !defined(SCHED_BG_NP)

define PY_PTHREAD_STD

else

define PY_PTHREAD_D7

endif

#elif defined(__DGUX)

define PY_PTHREAD_D6

#elif defined(__hpux) && defined(DECTHREADS)

define PY_PTHREAD_D4

#else /* Default case */

define PY_PTHREAD_STD

#endif

#ifdef USE_GUSI /* The Macintosh GUSI I/O library sets the stackspace to ** 20KB, much too low. We up it to 64K. */ #define THREAD_STACK_SIZE 0x10000 #endif

/* set default attribute object for different versions */

#if defined(PY_PTHREAD_D4) || defined(PY_PTHREAD_D7)

define pthread_attr_default pthread_attr_default

define pthread_mutexattr_default pthread_mutexattr_default

#elif defined(PY_PTHREAD_STD) || defined(PY_PTHREAD_D6)

define pthread_attr_default ((pthread_attr_t *)NULL)

define pthread_mutexattr_default ((pthread_mutexattr_t *)NULL)

#endif

/* On platforms that don't use standard POSIX threads pthread_sigmask()

#ifdef HAVE_PTHREAD_SIGMASK

define SET_THREAD_SIGMASK pthread_sigmask

#else

define SET_THREAD_SIGMASK sigprocmask

#endif

#define CHECK_STATUS(name) if (status != 0) { perror(name); error = 1; }

/*

#ifdef _HAVE_BSDI static void _noop(void) { }

static void PyThread__init_thread(void) { /* DO AN INIT BY STARTING THE THREAD */ static int dummy = 0; pthread_t thread1; pthread_create(&thread1, NULL, (void *) _noop, &dummy); pthread_join(thread1, NULL); }

#else /* !_HAVE_BSDI */

static void PyThread__init_thread(void) { #if defined(_AIX) && defined(GNUC) pthread_init(); #endif }

#endif /* !_HAVE_BSDI */

/*

long PyThread_start_new_thread(void (*func)(void *), void *arg) { pthread_t th; int success; sigset_t oldmask, newmask; #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED) pthread_attr_t attrs; #endif dprintf(("PyThread_start_new_thread called\n")); if (!initialized) PyThread_init_thread();

#if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED) pthread_attr_init(&attrs); #endif #ifdef THREAD_STACK_SIZE pthread_attr_setstacksize(&attrs, THREAD_STACK_SIZE); #endif #ifdef PTHREAD_SYSTEM_SCHED_SUPPORTED pthread_attr_setscope(&attrs, PTHREAD_SCOPE_SYSTEM); #endif

/* Mask all signals in the current thread before creating the new
 * thread.	This causes the new thread to start with all signals
 * blocked.
 */
sigfillset(&newmask);
SET_THREAD_SIGMASK(SIG_BLOCK, &newmask, &oldmask);

success = pthread_create(&th,

#if defined(PY_PTHREAD_D4) pthread_attr_default, (pthread_startroutine_t)func, (pthread_addr_t)arg #elif defined(PY_PTHREAD_D6) pthread_attr_default, (void* ()(void ))func, arg #elif defined(PY_PTHREAD_D7) pthread_attr_default, func, arg #elif defined(PY_PTHREAD_STD) #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED) &attrs, #else (pthread_attr_t)NULL, #endif (void (*)(void *))func, (void *)arg #endif );

/* Restore signal mask for original thread */
SET_THREAD_SIGMASK(SIG_SETMASK, &oldmask, NULL);

#if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED) pthread_attr_destroy(&attrs); #endif if (success == 0) { #if defined(PY_PTHREAD_D4) || defined(PY_PTHREAD_D6) || defined(PY_PTHREAD_D7) pthread_detach(&th); #elif defined(PY_PTHREAD_STD) pthread_detach(th); #endif } #if SIZEOF_PTHREAD_T <= SIZEOF_LONG return (long) th; #else return (long) *(long *) &th; #endif }

/* XXX This implementation is considered (to quote Tim Peters) "inherently hosed" because: - It does not guanrantee the promise that a non-zero integer is returned. - The cast to long is inherently unsafe. - It is not clear that the 'volatile' (for AIX?) and ugly casting in the latter return statement (for Alpha OSF/1) are any longer necessary. / long PyThread_get_thread_ident(void) { volatile pthread_t threadid; if (!initialized) PyThread_init_thread(); / Jump through some hoops for Alpha OSF/1 */ threadid = pthread_self(); #if SIZEOF_PTHREAD_T <= SIZEOF_LONG return (long) threadid; #else return (long) *(long *) &threadid; #endif }

static void do_PyThread_exit_thread(int no_cleanup) { dprintf(("PyThread_exit_thread called\n")); if (!initialized) { if (no_cleanup) _exit(0); else exit(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)); if (!initialized) 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 */

/*

PyThread_type_lock PyThread_allocate_lock(void) { sem_t *lock; int status, error = 0;

dprintf(("PyThread_allocate_lock called\n"));
if (!initialized)
    PyThread_init_thread();

lock = (sem_t *)malloc(sizeof(sem_t));

if (lock) {
    status = sem_init(lock,0,1);
    CHECK_STATUS("sem_init");

    if (error) {
        free((void *)lock);
        lock = NULL;
    }
}

dprintf(("PyThread_allocate_lock() -> %p\n", lock));
return (PyThread_type_lock)lock;

}

void PyThread_free_lock(PyThread_type_lock lock) { sem_t *thelock = (sem_t *)lock; int status, error = 0;

dprintf(("PyThread_free_lock(%p) called\n", lock));

if (!thelock)
    return;

status = sem_destroy(thelock);
CHECK_STATUS("sem_destroy");

free((void *)thelock);

}

int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag) { int success; sem_t *thelock = (sem_t *)lock; int status, error = 0;

dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));

if (waitflag) {
    status = sem_wait(thelock);
    CHECK_STATUS("sem_wait");
} else {
    status = sem_trywait(thelock);
}

success = (status == 0) ? 1 : 0;

dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
return success;

}

void PyThread_release_lock(PyThread_type_lock lock) { sem_t *thelock = (sem_t *)lock; int status, error = 0;

dprintf(("PyThread_release_lock(%p) called\n", lock));

status = sem_post(thelock);
CHECK_STATUS("sem_post");

}

/*

PyThread_type_sema PyThread_allocate_sema(int value) { sem_t *sema; int status, error = 0;

dprintf(("PyThread_allocate_sema called\n"));
if (!initialized)
    PyThread_init_thread();

sema = (sem_t *)malloc(sizeof(sem_t));

if (sema) {
    status = sem_init(sema,0,value);
    CHECK_STATUS("sem_init");

    if (error) {
        free((void *)sema);
        sema = NULL;
    }
}
dprintf(("PyThread_allocate_sema() -> %p\n",  sema));
return (PyThread_type_sema)sema;

}

void PyThread_free_sema(PyThread_type_sema sema) { int status, error = 0; sem_t *thesema = (sem_t *)sema;

dprintf(("PyThread_free_sema(%p) called\n",  sema));

if (!thesema)
    return;

status = sem_destroy(thesema);
CHECK_STATUS("sem_destroy");

free((void *) thesema);

}

int PyThread_down_sema(PyThread_type_sema sema, int waitflag) { int status, error = 0, success; sem_t *thesema = (sem_t *)sema;

dprintf(("PyThread_down_sema(%p, %d) called\n",  sema, waitflag));

if (waitflag) {
    status = sem_wait(thesema);
    CHECK_STATUS("sem_wait");
} else {
    status = sem_trywait(thesema);
}

success = (status == 0) ? 1 : 0;

dprintf(("PyThread_down_sema(%p) return\n",  sema));
return success;

}

void PyThread_up_sema(PyThread_type_sema sema) { int status, error = 0; sem_t *thesema = (sem_t *)sema;

dprintf(("PyThread_up_sema(%p)\n",	sema));

status = sem_post(thesema);
CHECK_STATUS("sem_post");

}

------=_NextPart_000_0023_01C1BFB7.CF9678F0 Content-Type: application/octet-stream; name="thread_posix.diff-c" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="thread_posix.diff-c"

*** thread_pthread.h Wed Feb 27 17:35:11 2002 --- thread_posix.h Wed Feb 27 17:39:30 2002

*** 5,10 **** --- 5,13 ---- #include <string.h> #include <pthread.h> #include <signal.h>

*** 288,293 **** --- 291,457 ---- } #endif /* NO_EXIT_PROG */

*** 497,499 **** --- 661,664 ---- status = pthread_mutex_unlock(&thesema->mutex); CHECK_STATUS("pthread_mutex_unlock"); }

------=_NextPart_000_0023_01C1BFB7.CF9678F0--