[Python-checkins] CVS: python/dist/src/Python thread_pthread.h,2.38,2.39

[Martin v. L?wis]

Update of /cvsroot/python/python/dist/src/Python
In directory usw-pr-cvs1:/tmp/cvs-serv15131

Modified Files:
	thread_pthread.h 
Log Message:
Patch #525532: Add support for POSIX semaphores.


Index: thread_pthread.h
===================================================================
RCS file: /cvsroot/python/python/dist/src/Python/thread_pthread.h,v
retrieving revision 2.38
retrieving revision 2.39
diff -C2 -d -r2.38 -r2.39
*** thread_pthread.h	19 Jan 2002 22:02:55 -0000	2.38
--- thread_pthread.h	17 Mar 2002 09:53:51 -0000	2.39
***************
*** 12,15 ****
--- 12,19 ----
  #endif
  #include <signal.h>
+ #ifdef _POSIX_SEMAPHORES
+ #include <semaphore.h>
+ #include <errno.h>
+ #endif
  
  
***************
*** 77,80 ****
--- 81,94 ----
  
  
+ /* Whether or not to use semaphores directly rather than emulating them with
+  * mutexes and condition variables:
+  */
+ #ifdef _POSIX_SEMAPHORES
+ #  define USE_SEMAPHORES
+ #else
+ #  undef USE_SEMAPHORES
+ #endif
+ 
+ 
  /* On platforms that don't use standard POSIX threads pthread_sigmask()
   * isn't present.  DEC threads uses sigprocmask() instead as do most
***************
*** 295,298 ****
--- 309,415 ----
  #endif /* NO_EXIT_PROG */
  
+ #ifdef USE_SEMAPHORES
+ 
+ /*
+  * Lock support.
+  */
+ 
+ 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);
+ }
+ 
+ /*
+  * As of February 2002, Cygwin thread implementations mistakenly report error
+  * codes in the return value of the sem_ calls (like the pthread_ functions).
+  * Correct implementations return -1 and put the code in errno. This supports
+  * either.
+  */
+ static int
+ fix_status(int status)
+ {
+ 	return (status == -1) ? errno : status;
+ }
+ 
+ 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));
+ 
+ 	do {
+ 		if (waitflag)
+ 			status = fix_status(sem_wait(thelock));
+ 		else
+ 			status = fix_status(sem_trywait(thelock));
+ 	} while (status == EINTR); /* Retry if interrupted by a signal */
+ 
+ 	if (waitflag) {
+ 		CHECK_STATUS("sem_wait");
+ 	} else if (status != EAGAIN) {
+ 		CHECK_STATUS("sem_trywait");
+ 	}
+ 	
+ 	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");
+ }
+ 
+ #else /* USE_SEMAPHORES */
+ 
  /*
   * Lock support.
***************
*** 406,407 ****
--- 523,526 ----
  	CHECK_STATUS("pthread_cond_signal");
  }
+ 
+ #endif /* USE_SEMAPHORES */