mirror of
https://github.com/python/cpython
synced 2024-09-05 16:38:56 +00:00
Remove the unused & broken PyThread_*_sema() functions and related constants.
This closes SF patch #504215.
This commit is contained in:
parent
72c3bf076f
commit
7bb1c9a11d
|
@ -25,13 +25,6 @@ DL_IMPORT(int) PyThread_acquire_lock(PyThread_type_lock, int);
|
|||
#define NOWAIT_LOCK 0
|
||||
DL_IMPORT(void) PyThread_release_lock(PyThread_type_lock);
|
||||
|
||||
DL_IMPORT(PyThread_type_sema) PyThread_allocate_sema(int);
|
||||
DL_IMPORT(void) PyThread_free_sema(PyThread_type_sema);
|
||||
DL_IMPORT(int) PyThread_down_sema(PyThread_type_sema, int);
|
||||
#define WAIT_SEMA 1
|
||||
#define NOWAIT_SEMA 0
|
||||
DL_IMPORT(void) PyThread_up_sema(PyThread_type_sema);
|
||||
|
||||
#ifndef NO_EXIT_PROG
|
||||
DL_IMPORT(void) PyThread_exit_prog(int);
|
||||
DL_IMPORT(void) PyThread__PyThread_exit_prog(int);
|
||||
|
|
|
@ -285,73 +285,3 @@ void PyThread_release_lock( PyThread_type_lock lock )
|
|||
return;
|
||||
}
|
||||
}
|
||||
|
||||
/* ----------------------------------------------------------------------
|
||||
* Semaphore support.
|
||||
*
|
||||
* Guido says not to implement this because it's not used anywhere;
|
||||
* I'll do it anyway, you never know when it might be handy, and it's
|
||||
* easy...
|
||||
*/
|
||||
PyThread_type_sema PyThread_allocate_sema( int value )
|
||||
{
|
||||
sem_id sema;
|
||||
|
||||
dprintf(("PyThread_allocate_sema called\n"));
|
||||
|
||||
sema = create_sem( value, "python semaphore" );
|
||||
if( sema < B_NO_ERROR ) {
|
||||
/* TODO: that's bad, raise an exception */
|
||||
return 0;
|
||||
}
|
||||
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void PyThread_free_sema( PyThread_type_sema sema )
|
||||
{
|
||||
status_t retval;
|
||||
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
|
||||
retval = delete_sem( (sem_id)sema );
|
||||
if( retval != B_NO_ERROR ) {
|
||||
/* TODO: that's bad, raise an exception */
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
int PyThread_down_sema( PyThread_type_sema sema, int waitflag )
|
||||
{
|
||||
status_t retval;
|
||||
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
|
||||
if( waitflag ) {
|
||||
retval = acquire_sem( (sem_id)sema );
|
||||
} else {
|
||||
retval = acquire_sem_etc( (sem_id)sema, 1, B_TIMEOUT, 0 );
|
||||
}
|
||||
|
||||
if( retval != B_NO_ERROR ) {
|
||||
/* TODO: that's bad, raise an exception */
|
||||
return 0;
|
||||
}
|
||||
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return -1;
|
||||
}
|
||||
|
||||
void PyThread_up_sema( PyThread_type_sema sema )
|
||||
{
|
||||
status_t retval;
|
||||
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
|
||||
retval = release_sem( (sem_id)sema );
|
||||
if( retval != B_NO_ERROR ) {
|
||||
/* TODO: that's bad, raise an exception */
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
|
@ -154,49 +154,3 @@ PyThread_release_lock(PyThread_type_lock lock)
|
|||
dprintf(("PyThread_release_lock(%p) called\n", lock));
|
||||
mutex_unlock((mutex_t )lock);
|
||||
}
|
||||
|
||||
/*
|
||||
* Semaphore support.
|
||||
*
|
||||
* This implementation is ripped directly from the pthreads implementation.
|
||||
* Which is to say that it is 100% non-functional at this time.
|
||||
*
|
||||
* Assuming the page is still up, documentation can be found at:
|
||||
*
|
||||
* http://www.doc.ic.ac.uk/~mac/manuals/solaris-manual-pages/solaris/usr/man/man2/_lwp_sema_wait.2.html
|
||||
*
|
||||
* Looking at the man page, it seems that one could easily implement a
|
||||
* semaphore using a condition.
|
||||
*
|
||||
*/
|
||||
PyThread_type_sema
|
||||
PyThread_allocate_sema(int value)
|
||||
{
|
||||
char *sema = 0;
|
||||
dprintf(("PyThread_allocate_sema called\n"));
|
||||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void
|
||||
PyThread_free_sema(PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
}
|
||||
|
||||
int
|
||||
PyThread_down_sema(PyThread_type_sema sema, int waitflag)
|
||||
{
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return -1;
|
||||
}
|
||||
|
||||
void
|
||||
PyThread_up_sema(PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
}
|
||||
|
|
|
@ -113,37 +113,3 @@ PyThread_release_lock(PyThread_type_lock lock)
|
|||
{
|
||||
dprintf(("PyThread_release_lock(%p) called\n", lock));
|
||||
}
|
||||
|
||||
/*
|
||||
* Semaphore support.
|
||||
*/
|
||||
PyThread_type_sema
|
||||
PyThread_allocate_sema(int value)
|
||||
{
|
||||
dprintf(("PyThread_allocate_sema called\n"));
|
||||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void
|
||||
PyThread_free_sema(PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
}
|
||||
|
||||
int
|
||||
PyThread_down_sema(PyThread_type_sema sema, int waitflag)
|
||||
{
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return -1;
|
||||
}
|
||||
|
||||
void
|
||||
PyThread_up_sema(PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
}
|
||||
|
|
|
@ -147,34 +147,3 @@ void PyThread_release_lock(PyThread_type_lock lock)
|
|||
cv_broadcast(((struct lock *) lock)->lock_condvar);
|
||||
mon_exit(((struct lock *) lock)->lock_monitor);
|
||||
}
|
||||
|
||||
/*
|
||||
* Semaphore support.
|
||||
*/
|
||||
PyThread_type_sema PyThread_allocate_sema(int value)
|
||||
{
|
||||
PyThread_type_sema sema = 0;
|
||||
dprintf(("PyThread_allocate_sema called\n"));
|
||||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void PyThread_free_sema(PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
}
|
||||
|
||||
int PyThread_down_sema(PyThread_type_sema sema, int waitflag)
|
||||
{
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return -1;
|
||||
}
|
||||
|
||||
void PyThread_up_sema(PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
}
|
||||
|
|
|
@ -319,56 +319,3 @@ void PyThread_release_lock(PyThread_type_lock aLock)
|
|||
if (!(aLock && LeaveNonRecursiveMutex((PNRMUTEX) aLock)))
|
||||
dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n", PyThread_get_thread_ident(), aLock, GetLastError()));
|
||||
}
|
||||
|
||||
/*
|
||||
* Semaphore support.
|
||||
*/
|
||||
PyThread_type_sema PyThread_allocate_sema(int value)
|
||||
{
|
||||
HANDLE aSemaphore;
|
||||
|
||||
dprintf(("%ld: PyThread_allocate_sema called\n", PyThread_get_thread_ident()));
|
||||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
aSemaphore = CreateSemaphore( NULL, /* Security attributes */
|
||||
value, /* Initial value */
|
||||
INT_MAX, /* Maximum value */
|
||||
NULL); /* Name of semaphore */
|
||||
|
||||
dprintf(("%ld: PyThread_allocate_sema() -> %p\n", PyThread_get_thread_ident(), aSemaphore));
|
||||
|
||||
return (PyThread_type_sema) aSemaphore;
|
||||
}
|
||||
|
||||
void PyThread_free_sema(PyThread_type_sema aSemaphore)
|
||||
{
|
||||
dprintf(("%ld: PyThread_free_sema(%p) called\n", PyThread_get_thread_ident(), aSemaphore));
|
||||
|
||||
CloseHandle((HANDLE) aSemaphore);
|
||||
}
|
||||
|
||||
/*
|
||||
XXX must do something about waitflag
|
||||
*/
|
||||
int PyThread_down_sema(PyThread_type_sema aSemaphore, int waitflag)
|
||||
{
|
||||
DWORD waitResult;
|
||||
|
||||
dprintf(("%ld: PyThread_down_sema(%p) called\n", PyThread_get_thread_ident(), aSemaphore));
|
||||
|
||||
waitResult = WaitForSingleObject( (HANDLE) aSemaphore, INFINITE);
|
||||
|
||||
dprintf(("%ld: PyThread_down_sema(%p) return: %l\n", PyThread_get_thread_ident(), aSemaphore, waitResult));
|
||||
return 0;
|
||||
}
|
||||
|
||||
void PyThread_up_sema(PyThread_type_sema aSemaphore)
|
||||
{
|
||||
ReleaseSemaphore(
|
||||
(HANDLE) aSemaphore, /* Handle of semaphore */
|
||||
1, /* increment count by one */
|
||||
NULL); /* not interested in previous count */
|
||||
|
||||
dprintf(("%ld: PyThread_up_sema(%p)\n", PyThread_get_thread_ident(), aSemaphore));
|
||||
}
|
||||
|
|
|
@ -209,30 +209,3 @@ void PyThread_release_lock(PyThread_type_lock aLock)
|
|||
|
||||
DosExitCritSec();
|
||||
}
|
||||
|
||||
/*
|
||||
* Semaphore support.
|
||||
*/
|
||||
PyThread_type_sema
|
||||
PyThread_allocate_sema(int value)
|
||||
{
|
||||
return (PyThread_type_sema) 0;
|
||||
}
|
||||
|
||||
void
|
||||
PyThread_free_sema(PyThread_type_sema aSemaphore)
|
||||
{
|
||||
|
||||
}
|
||||
|
||||
int
|
||||
PyThread_down_sema(PyThread_type_sema aSemaphore, int waitflag)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
void
|
||||
PyThread_up_sema(PyThread_type_sema aSemaphore)
|
||||
{
|
||||
dprintf(("%ld: PyThread_up_sema(%p)\n", PyThread_get_thread_ident(), aSemaphore));
|
||||
}
|
||||
|
|
|
@ -206,90 +206,3 @@ void PyThread_release_lock(PyThread_type_lock lock)
|
|||
status = pth_cond_notify( &thelock->lock_released, 0 );
|
||||
CHECK_STATUS("pth_cond_notify");
|
||||
}
|
||||
|
||||
/*
|
||||
* Semaphore support.
|
||||
*/
|
||||
|
||||
struct semaphore {
|
||||
pth_mutex_t mutex;
|
||||
pth_cond_t cond;
|
||||
int value;
|
||||
};
|
||||
|
||||
PyThread_type_sema PyThread_allocate_sema(int value)
|
||||
{
|
||||
struct semaphore *sema;
|
||||
int status, error = 0;
|
||||
|
||||
dprintf(("PyThread_allocate_sema called\n"));
|
||||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
sema = (struct semaphore *) malloc(sizeof(struct semaphore));
|
||||
if (sema != NULL) {
|
||||
sema->value = value;
|
||||
status = pth_mutex_init(&sema->mutex);
|
||||
CHECK_STATUS("pth_mutex_init");
|
||||
status = pth_cond_init(&sema->cond);
|
||||
CHECK_STATUS("pth_mutex_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)
|
||||
{
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
free((void *) thesema);
|
||||
}
|
||||
|
||||
int PyThread_down_sema(PyThread_type_sema sema, int waitflag)
|
||||
{
|
||||
int status, error = 0, success;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
status = pth_mutex_acquire(&thesema->mutex, !waitflag, NULL);
|
||||
CHECK_STATUS("pth_mutex_acquire");
|
||||
if (waitflag) {
|
||||
while (!error && thesema->value <= 0) {
|
||||
status = pth_cond_await(&thesema->cond,
|
||||
&thesema->mutex, NULL);
|
||||
CHECK_STATUS("pth_cond_await");
|
||||
}
|
||||
}
|
||||
if (error)
|
||||
success = 0;
|
||||
else if (thesema->value > 0) {
|
||||
thesema->value--;
|
||||
success = 1;
|
||||
}
|
||||
else
|
||||
success = 0;
|
||||
status = pth_mutex_release(&thesema->mutex);
|
||||
CHECK_STATUS("pth_mutex_release");
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_up_sema(PyThread_type_sema sema)
|
||||
{
|
||||
int status, error = 0;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
status = pth_mutex_acquire(&thesema->mutex, 0, NULL);
|
||||
CHECK_STATUS("pth_mutex_acquire");
|
||||
thesema->value++;
|
||||
status = pth_cond_notify(&thesema->cond, 1);
|
||||
CHECK_STATUS("pth_cond_notify");
|
||||
status = pth_mutex_release(&thesema->mutex);
|
||||
CHECK_STATUS("pth_mutex_release");
|
||||
}
|
||||
|
|
|
@ -405,101 +405,3 @@ PyThread_release_lock(PyThread_type_lock lock)
|
|||
status = pthread_cond_signal( &thelock->lock_released );
|
||||
CHECK_STATUS("pthread_cond_signal");
|
||||
}
|
||||
|
||||
/*
|
||||
* Semaphore support.
|
||||
*/
|
||||
|
||||
struct semaphore {
|
||||
pthread_mutex_t mutex;
|
||||
pthread_cond_t cond;
|
||||
int value;
|
||||
};
|
||||
|
||||
PyThread_type_sema
|
||||
PyThread_allocate_sema(int value)
|
||||
{
|
||||
struct semaphore *sema;
|
||||
int status, error = 0;
|
||||
|
||||
dprintf(("PyThread_allocate_sema called\n"));
|
||||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
sema = (struct semaphore *) malloc(sizeof(struct semaphore));
|
||||
if (sema != NULL) {
|
||||
sema->value = value;
|
||||
status = pthread_mutex_init(&sema->mutex,
|
||||
pthread_mutexattr_default);
|
||||
CHECK_STATUS("pthread_mutex_init");
|
||||
status = pthread_cond_init(&sema->cond,
|
||||
pthread_condattr_default);
|
||||
CHECK_STATUS("pthread_cond_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;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
status = pthread_cond_destroy(&thesema->cond);
|
||||
CHECK_STATUS("pthread_cond_destroy");
|
||||
status = pthread_mutex_destroy(&thesema->mutex);
|
||||
CHECK_STATUS("pthread_mutex_destroy");
|
||||
free((void *) thesema);
|
||||
}
|
||||
|
||||
int
|
||||
PyThread_down_sema(PyThread_type_sema sema, int waitflag)
|
||||
{
|
||||
int status, error = 0, success;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_down_sema(%p, %d) called\n", sema, waitflag));
|
||||
status = pthread_mutex_lock(&thesema->mutex);
|
||||
CHECK_STATUS("pthread_mutex_lock");
|
||||
if (waitflag) {
|
||||
while (!error && thesema->value <= 0) {
|
||||
status = pthread_cond_wait(&thesema->cond,
|
||||
&thesema->mutex);
|
||||
CHECK_STATUS("pthread_cond_wait");
|
||||
}
|
||||
}
|
||||
if (error)
|
||||
success = 0;
|
||||
else if (thesema->value > 0) {
|
||||
thesema->value--;
|
||||
success = 1;
|
||||
}
|
||||
else
|
||||
success = 0;
|
||||
status = pthread_mutex_unlock(&thesema->mutex);
|
||||
CHECK_STATUS("pthread_mutex_unlock");
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return success;
|
||||
}
|
||||
|
||||
void
|
||||
PyThread_up_sema(PyThread_type_sema sema)
|
||||
{
|
||||
int status, error = 0;
|
||||
struct semaphore *thesema = (struct semaphore *) sema;
|
||||
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
status = pthread_mutex_lock(&thesema->mutex);
|
||||
CHECK_STATUS("pthread_mutex_lock");
|
||||
thesema->value++;
|
||||
status = pthread_cond_signal(&thesema->cond);
|
||||
CHECK_STATUS("pthread_cond_signal");
|
||||
status = pthread_mutex_unlock(&thesema->mutex);
|
||||
CHECK_STATUS("pthread_mutex_unlock");
|
||||
}
|
||||
|
|
|
@ -378,50 +378,6 @@ void PyThread_release_lock(PyThread_type_lock lock)
|
|||
perror("usunsetlock");
|
||||
}
|
||||
|
||||
/*
|
||||
* Semaphore support.
|
||||
*/
|
||||
PyThread_type_sema PyThread_allocate_sema(int value)
|
||||
{
|
||||
usema_t *sema;
|
||||
dprintf(("PyThread_allocate_sema called\n"));
|
||||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
if ((sema = usnewsema(shared_arena, value)) == NULL)
|
||||
perror("usnewsema");
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void PyThread_free_sema(PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
usfreesema((usema_t *) sema, shared_arena);
|
||||
}
|
||||
|
||||
int PyThread_down_sema(PyThread_type_sema sema, int waitflag)
|
||||
{
|
||||
int success;
|
||||
|
||||
dprintf(("PyThread_down_sema(%p) called\n", sema));
|
||||
if (waitflag)
|
||||
success = uspsema((usema_t *) sema);
|
||||
else
|
||||
success = uscpsema((usema_t *) sema);
|
||||
if (success < 0)
|
||||
perror(waitflag ? "uspsema" : "uscpsema");
|
||||
dprintf(("PyThread_down_sema(%p) return\n", sema));
|
||||
return success;
|
||||
}
|
||||
|
||||
void PyThread_up_sema(PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
if (usvsema((usema_t *) sema) < 0)
|
||||
perror("usvsema");
|
||||
}
|
||||
|
||||
/*
|
||||
* Per-thread data ("key") support.
|
||||
*/
|
||||
|
|
|
@ -174,63 +174,3 @@ PyThread_release_lock(PyThread_type_lock lock)
|
|||
if (mutex_unlock((mutex_t *) lock))
|
||||
perror("mutex_unlock");
|
||||
}
|
||||
|
||||
/*
|
||||
* Semaphore support.
|
||||
*/
|
||||
PyThread_type_sema
|
||||
PyThread_allocate_sema(int value)
|
||||
{
|
||||
sema_t *sema;
|
||||
dprintf(("PyThread_allocate_sema called\n"));
|
||||
if (!initialized)
|
||||
PyThread_init_thread();
|
||||
|
||||
sema = (sema_t *) malloc(sizeof(sema_t));
|
||||
if (sema_init(sema, value, USYNC_THREAD, 0)) {
|
||||
perror("sema_init");
|
||||
free((void *) sema);
|
||||
sema = 0;
|
||||
}
|
||||
dprintf(("PyThread_allocate_sema() -> %p\n", sema));
|
||||
return (PyThread_type_sema) sema;
|
||||
}
|
||||
|
||||
void
|
||||
PyThread_free_sema(PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_free_sema(%p) called\n", sema));
|
||||
if (sema_destroy((sema_t *) sema))
|
||||
perror("sema_destroy");
|
||||
free((void *) sema);
|
||||
}
|
||||
|
||||
int
|
||||
PyThread_down_sema(PyThread_type_sema sema, int waitflag)
|
||||
{
|
||||
int success;
|
||||
|
||||
dprintf(("PyThread_down_sema(%p) called\n", sema));
|
||||
if (waitflag)
|
||||
success = sema_wait((sema_t *) sema);
|
||||
else
|
||||
success = sema_trywait((sema_t *) sema);
|
||||
if (success < 0) {
|
||||
if (errno == EBUSY)
|
||||
success = 0;
|
||||
else
|
||||
perror("sema_wait");
|
||||
}
|
||||
else
|
||||
success = !success;
|
||||
dprintf(("PyThread_down_sema(%p) return %d\n", sema, success));
|
||||
return success;
|
||||
}
|
||||
|
||||
void
|
||||
PyThread_up_sema(PyThread_type_sema sema)
|
||||
{
|
||||
dprintf(("PyThread_up_sema(%p)\n", sema));
|
||||
if (sema_post((sema_t *) sema))
|
||||
perror("sema_post");
|
||||
}
|
||||
|
|
Loading…
Reference in a new issue