Changeset 391 for python/trunk/Python/thread_pthread.h

Timestamp:

Mar 19, 2014, 11:31:01 PM (11 years ago)

Author:

dmik

Message:

python: Merge vendor 2.7.6 to trunk.

Location:

python/trunk

Files:

• . (modified) (1 prop)
• Python/thread_pthread.h (modified) (11 diffs)

python/trunk/Python/thread_pthread.h

@@ -17 +17 @@
 #ifdef _POSIX_THREAD_ATTR_STACKSIZE
 #ifndef THREAD_STACK_SIZE
-#define THREAD_STACK_SIZE       0       /* use default stack size */
+#define THREAD_STACK_SIZE       0       /* use default stack size */
+#endif
+
+#if (defined(__APPLE__) || defined(__FreeBSD__)) && defined(THREAD_STACK_SIZE) && THREAD_STACK_SIZE == 0
+   /* The default stack size for new threads on OSX is small enough that
+    * we'll get hard crashes instead of 'maximum recursion depth exceeded'
+    * exceptions.
+    *
+    * The default stack size below is the minimal stack size where a
+    * simple recursive function doesn't cause a hard crash.
+    */
+#undef  THREAD_STACK_SIZE
+#define THREAD_STACK_SIZE       0x400000
 #endif
 /* for safety, ensure a viable minimum stacksize */
-#define THREAD_STACK_MIN        0x8000  /* 32kB */
+#define THREAD_STACK_MIN        0x8000  /* 32kB */
 #else  /* !_POSIX_THREAD_ATTR_STACKSIZE */
 #ifdef THREAD_STACK_SIZE
@@ -29 +41 @@
 /* The POSIX spec says that implementations supporting the sem_*
    family of functions must indicate this by defining
-   _POSIX_SEMAPHORES. */   
+   _POSIX_SEMAPHORES. */
 #ifdef _POSIX_SEMAPHORES
-/* On FreeBSD 4.x, _POSIX_SEMAPHORES is defined empty, so 
+/* On FreeBSD 4.x, _POSIX_SEMAPHORES is defined empty, so
    we need to add 0 to make it work there as well. */
 #if (_POSIX_SEMAPHORES+0) == -1
@@ -100 +112 @@
 
 typedef struct {
-        char             locked; /* 0=unlocked, 1=locked */
-        /* a <cond, mutex> pair to handle an acquire of a locked lock */
-        pthread_cond_t   lock_released;
-        pthread_mutex_t  mut;
+    char             locked; /* 0=unlocked, 1=locked */
+    /* a <cond, mutex> pair to handle an acquire of a locked lock */
+    pthread_cond_t   lock_released;
+    pthread_mutex_t  mut;
 } pthread_lock;
 
@@ -121 +133 @@
 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);
+    /* 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);
 }
 
@@ -134 +146 @@
 {
 #if defined(_AIX) && defined(__GNUC__)
-        pthread_init();
+    extern void pthread_init(void);
+    pthread_init();
 #endif
 }
@@ -148 +161 @@
 PyThread_start_new_thread(void (*func)(void *), void *arg)
 {
-        pthread_t th;
-        int status;
+    pthread_t th;
+    int status;
 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
-        pthread_attr_t attrs;
+    pthread_attr_t attrs;
 #endif
 #if defined(THREAD_STACK_SIZE)
-        size_t  tss;
-#endif
-
-        dprintf(("PyThread_start_new_thread called\n"));
-        if (!initialized)
-                PyThread_init_thread();
+    size_t      tss;
+#endif
+
+    dprintf(("PyThread_start_new_thread called\n"));
+    if (!initialized)
+        PyThread_init_thread();
 
 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
-        if (pthread_attr_init(&attrs) != 0)
-                return -1;
+    if (pthread_attr_init(&attrs) != 0)
+        return -1;
 #endif
 #if defined(THREAD_STACK_SIZE)
-        tss = (_pythread_stacksize != 0) ? _pythread_stacksize
-                                         : THREAD_STACK_SIZE;
-        if (tss != 0) {
-                if (pthread_attr_setstacksize(&attrs, tss) != 0) {
-                        pthread_attr_destroy(&attrs);
-                        return -1;
-                }
-        }
+    tss = (_pythread_stacksize != 0) ? _pythread_stacksize
+                                     : THREAD_STACK_SIZE;
+    if (tss != 0) {
+        if (pthread_attr_setstacksize(&attrs, tss) != 0) {
+            pthread_attr_destroy(&attrs);
+            return -1;
+        }
+    }
 #endif
 #if defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
-        pthread_attr_setscope(&attrs, PTHREAD_SCOPE_SYSTEM);
-#endif
-
-        status = pthread_create(&th, 
+    pthread_attr_setscope(&attrs, PTHREAD_SCOPE_SYSTEM);
+#endif
+
+    status = pthread_create(&th,
 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
-                                 &attrs,
-#else
-                                 (pthread_attr_t*)NULL,
-#endif
-                                 (void* (*)(void *))func,
-                                 (void *)arg
-                                 );
+                             &attrs,
+#else
+                             (pthread_attr_t*)NULL,
+#endif
+                             (void* (*)(void *))func,
+                             (void *)arg
+                             );
 
 #if defined(THREAD_STACK_SIZE) || defined(PTHREAD_SYSTEM_SCHED_SUPPORTED)
-        pthread_attr_destroy(&attrs);
-#endif
-        if (status != 0)
-            return -1;
-
-        pthread_detach(th);
+    pthread_attr_destroy(&attrs);
+#endif
+    if (status != 0)
+        return -1;
+
+    pthread_detach(th);
 
 #if SIZEOF_PTHREAD_T <= SIZEOF_LONG
-        return (long) th;
-#else
-        return (long) *(long *) &th;
+    return (long) th;
+#else
+    return (long) *(long *) &th;
 #endif
 }
@@ -211 +224 @@
        latter return statement (for Alpha OSF/1) are any longer necessary.
 */
-long 
+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();
+    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 
+    return (long) threadid;
+#else
+    return (long) *(long *) &threadid;
+#endif
+}
+
+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 */
+    dprintf(("PyThread_exit_thread called\n"));
+    if (!initialized) {
+        exit(0);
+    }
+}
 
 #ifdef USE_SEMAPHORES
@@ -281 +254 @@
  */
 
-PyThread_type_lock 
+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 
+    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);
+    sem_t *thelock = (sem_t *)lock;
+    int status, error = 0;
+
+    (void) error; /* silence unused-but-set-variable warning */
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
+
+    if (!thelock)
+        return;
+
+    status = sem_destroy(thelock);
+    CHECK_STATUS("sem_destroy");
+
+    free((void *)thelock);
 }
 
@@ -333 +307 @@
 fix_status(int status)
 {
-        return (status == -1) ? errno : status;
-}
-
-int 
+    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 
+    int success;
+    sem_t *thelock = (sem_t *)lock;
+    int status, error = 0;
+
+    (void) error; /* silence unused-but-set-variable warning */
+    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");
+    sem_t *thelock = (sem_t *)lock;
+    int status, error = 0;
+
+    (void) error; /* silence unused-but-set-variable warning */
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
+
+    status = sem_post(thelock);
+    CHECK_STATUS("sem_post");
 }
 
@@ -381 +357 @@
  * Lock support.
  */
-PyThread_type_lock 
+PyThread_type_lock
 PyThread_allocate_lock(void)
 {
-        pthread_lock *lock;
-        int status, error = 0;
-
-        dprintf(("PyThread_allocate_lock called\n"));
-        if (!initialized)
-                PyThread_init_thread();
-
-        lock = (pthread_lock *) malloc(sizeof(pthread_lock));
-        if (lock) {
-                memset((void *)lock, '\0', sizeof(pthread_lock));
-                lock->locked = 0;
-
-                status = pthread_mutex_init(&lock->mut,
-                                            pthread_mutexattr_default);
-                CHECK_STATUS("pthread_mutex_init");
-
-                status = pthread_cond_init(&lock->lock_released,
-                                           pthread_condattr_default);
-                CHECK_STATUS("pthread_cond_init");
-
-                if (error) {
-                        free((void *)lock);
-                        lock = 0;
-                }
-        }
-
-        dprintf(("PyThread_allocate_lock() -> %p\n", lock));
-        return (PyThread_type_lock) lock;
-}
-
-void 
+    pthread_lock *lock;
+    int status, error = 0;
+
+    dprintf(("PyThread_allocate_lock called\n"));
+    if (!initialized)
+        PyThread_init_thread();
+
+    lock = (pthread_lock *) malloc(sizeof(pthread_lock));
+    if (lock) {
+        memset((void *)lock, '\0', sizeof(pthread_lock));
+        lock->locked = 0;
+
+        status = pthread_mutex_init(&lock->mut,
+                                    pthread_mutexattr_default);
+        CHECK_STATUS("pthread_mutex_init");
+
+        status = pthread_cond_init(&lock->lock_released,
+                                   pthread_condattr_default);
+        CHECK_STATUS("pthread_cond_init");
+
+        if (error) {
+            free((void *)lock);
+            lock = 0;
+        }
+    }
+
+    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
+    return (PyThread_type_lock) lock;
+}
+
+void
 PyThread_free_lock(PyThread_type_lock lock)
 {
-        pthread_lock *thelock = (pthread_lock *)lock;
-        int status, error = 0;
-
-        dprintf(("PyThread_free_lock(%p) called\n", lock));
-
-        status = pthread_mutex_destroy( &thelock->mut );
-        CHECK_STATUS("pthread_mutex_destroy");
-
-        status = pthread_cond_destroy( &thelock->lock_released );
-        CHECK_STATUS("pthread_cond_destroy");
-
-        free((void *)thelock);
-}
-
-int 
+    pthread_lock *thelock = (pthread_lock *)lock;
+    int status, error = 0;
+
+    (void) error; /* silence unused-but-set-variable warning */
+    dprintf(("PyThread_free_lock(%p) called\n", lock));
+
+    status = pthread_mutex_destroy( &thelock->mut );
+    CHECK_STATUS("pthread_mutex_destroy");
+
+    status = pthread_cond_destroy( &thelock->lock_released );
+    CHECK_STATUS("pthread_cond_destroy");
+
+    free((void *)thelock);
+}
+
+int
 PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 {
-        int success;
-        pthread_lock *thelock = (pthread_lock *)lock;
-        int status, error = 0;
-
-        dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
-
-        status = pthread_mutex_lock( &thelock->mut );
-        CHECK_STATUS("pthread_mutex_lock[1]");
-        success = thelock->locked == 0;
-
-        if ( !success && waitflag ) {
-                /* continue trying until we get the lock */
-
-                /* mut must be locked by me -- part of the condition
-                 * protocol */
-                while ( thelock->locked ) {
-                        status = pthread_cond_wait(&thelock->lock_released,
-                                                   &thelock->mut);
-                        CHECK_STATUS("pthread_cond_wait");
-                }
-                success = 1;
-        }
-        if (success) thelock->locked = 1;
-        status = pthread_mutex_unlock( &thelock->mut );
-        CHECK_STATUS("pthread_mutex_unlock[1]");
-
-        if (error) success = 0;
-        dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
-        return success;
-}
-
-void 
+    int success;
+    pthread_lock *thelock = (pthread_lock *)lock;
+    int status, error = 0;
+
+    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
+
+    status = pthread_mutex_lock( &thelock->mut );
+    CHECK_STATUS("pthread_mutex_lock[1]");
+    success = thelock->locked == 0;
+
+    if ( !success && waitflag ) {
+        /* continue trying until we get the lock */
+
+        /* mut must be locked by me -- part of the condition
+         * protocol */
+        while ( thelock->locked ) {
+            status = pthread_cond_wait(&thelock->lock_released,
+                                       &thelock->mut);
+            CHECK_STATUS("pthread_cond_wait");
+        }
+        success = 1;
+    }
+    if (success) thelock->locked = 1;
+    status = pthread_mutex_unlock( &thelock->mut );
+    CHECK_STATUS("pthread_mutex_unlock[1]");
+
+    if (error) success = 0;
+    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
+    return success;
+}
+
+void
 PyThread_release_lock(PyThread_type_lock lock)
 {
-        pthread_lock *thelock = (pthread_lock *)lock;
-        int status, error = 0;
-
-        dprintf(("PyThread_release_lock(%p) called\n", lock));
-
-        status = pthread_mutex_lock( &thelock->mut );
-        CHECK_STATUS("pthread_mutex_lock[3]");
-
-        thelock->locked = 0;
-
-        status = pthread_mutex_unlock( &thelock->mut );
-        CHECK_STATUS("pthread_mutex_unlock[3]");
-
-        /* wake up someone (anyone, if any) waiting on the lock */
-        status = pthread_cond_signal( &thelock->lock_released );
-        CHECK_STATUS("pthread_cond_signal");
+    pthread_lock *thelock = (pthread_lock *)lock;
+    int status, error = 0;
+
+    (void) error; /* silence unused-but-set-variable warning */
+    dprintf(("PyThread_release_lock(%p) called\n", lock));
+
+    status = pthread_mutex_lock( &thelock->mut );
+    CHECK_STATUS("pthread_mutex_lock[3]");
+
+    thelock->locked = 0;
+
+    status = pthread_mutex_unlock( &thelock->mut );
+    CHECK_STATUS("pthread_mutex_unlock[3]");
+
+    /* wake up someone (anyone, if any) waiting on the lock */
+    status = pthread_cond_signal( &thelock->lock_released );
+    CHECK_STATUS("pthread_cond_signal");
 }
 
@@ -496 +474 @@
 {
 #if defined(THREAD_STACK_SIZE)
-        pthread_attr_t attrs;
-        size_t tss_min;
-        int rc = 0;
-#endif
-
-        /* set to default */
-        if (size == 0) {
-                _pythread_stacksize = 0;
-                return 0;
-        }
+    pthread_attr_t attrs;
+    size_t tss_min;
+    int rc = 0;
+#endif
+
+    /* set to default */
+    if (size == 0) {
+        _pythread_stacksize = 0;
+        return 0;
+    }
 
 #if defined(THREAD_STACK_SIZE)
 #if defined(PTHREAD_STACK_MIN)
-        tss_min = PTHREAD_STACK_MIN > THREAD_STACK_MIN ? PTHREAD_STACK_MIN
-                                                       : THREAD_STACK_MIN;
-#else
-        tss_min = THREAD_STACK_MIN;
-#endif
-        if (size >= tss_min) {
-                /* validate stack size by setting thread attribute */
-                if (pthread_attr_init(&attrs) == 0) {
-                        rc = pthread_attr_setstacksize(&attrs, size);
-                        pthread_attr_destroy(&attrs);
-                        if (rc == 0) {
-                                _pythread_stacksize = size;
-                                return 0;
-                        }
-                }
-        }
-        return -1;
-#else
-        return -2;
-#endif
-}
-
-#define THREAD_SET_STACKSIZE(x) _pythread_pthread_set_stacksize(x)
+    tss_min = PTHREAD_STACK_MIN > THREAD_STACK_MIN ? PTHREAD_STACK_MIN
+                                                   : THREAD_STACK_MIN;
+#else
+    tss_min = THREAD_STACK_MIN;
+#endif
+    if (size >= tss_min) {
+        /* validate stack size by setting thread attribute */
+        if (pthread_attr_init(&attrs) == 0) {
+            rc = pthread_attr_setstacksize(&attrs, size);
+            pthread_attr_destroy(&attrs);
+            if (rc == 0) {
+                _pythread_stacksize = size;
+                return 0;
+            }
+        }
+    }
+    return -1;
+#else
+    return -2;
+#endif
+}
+
+#define THREAD_SET_STACKSIZE(x) _pythread_pthread_set_stacksize(x)