Ignore:
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:
2 edited

Legend:

Unmodified
Added
Removed

  • python/trunk

  • python/trunk/Python/thread_pth.h

    r2 r391  
    44   2000-05-03 Andy Dustman <andy@dustman.net>
    55
    6    Adapted from Posix threads interface 
     6   Adapted from Posix threads interface
    77   12 May 1997 -- david arnold <davida@pobox.com>
    88 */
    … …  
    2323
    2424typedef struct {
    25         char             locked; /* 0=unlocked, 1=locked */
    26         /* a <cond, mutex> pair to handle an acquire of a locked lock */
    27         pth_cond_t   lock_released;
    28         pth_mutex_t  mut;
     25    char             locked; /* 0=unlocked, 1=locked */
     26    /* a <cond, mutex> pair to handle an acquire of a locked lock */
     27    pth_cond_t   lock_released;
     28    pth_mutex_t  mut;
    2929} pth_lock;
    3030
    … …  
    3939static void PyThread__init_thread(void)
    4040{
    41         pth_init();
    42         PyThread_attr = pth_attr_new();
    43         pth_attr_set(PyThread_attr, PTH_ATTR_STACK_SIZE, 1<<18);
    44         pth_attr_set(PyThread_attr, PTH_ATTR_JOINABLE, FALSE);
     41    pth_init();
     42    PyThread_attr = pth_attr_new();
     43    pth_attr_set(PyThread_attr, PTH_ATTR_STACK_SIZE, 1<<18);
     44    pth_attr_set(PyThread_attr, PTH_ATTR_JOINABLE, FALSE);
    4545}
    4646
    … …  
    5252long PyThread_start_new_thread(void (*func)(void *), void *arg)
    5353{
    54         pth_t th;
    55         dprintf(("PyThread_start_new_thread called\n"));
    56         if (!initialized)
    57                 PyThread_init_thread();
     54    pth_t th;
     55    dprintf(("PyThread_start_new_thread called\n"));
     56    if (!initialized)
     57        PyThread_init_thread();
    5858
    59         th = pth_spawn(PyThread_attr,
    60                                 (void* (*)(void *))func,
    61                                 (void *)arg
    62                                 );
     59    th = pth_spawn(PyThread_attr,
     60                            (void* (*)(void *))func,
     61                            (void *)arg
     62                            );
    6363
    64         return th;
     64    return th;
    6565}
    6666
    6767long PyThread_get_thread_ident(void)
    6868{
    69         volatile pth_t threadid;
    70         if (!initialized)
    71                 PyThread_init_thread();
    72         /* Jump through some hoops for Alpha OSF/1 */
    73         threadid = pth_self();
    74         return (long) *(long *) &threadid;
    75 }
    76 
    77 static void do_PyThread_exit_thread(int no_cleanup)
    78 {
    79         dprintf(("PyThread_exit_thread called\n"));
    80         if (!initialized) {
    81                 if (no_cleanup)
    82                         _exit(0);
    83                 else
    84                         exit(0);
    85         }
     69    volatile pth_t threadid;
     70    if (!initialized)
     71        PyThread_init_thread();
     72    /* Jump through some hoops for Alpha OSF/1 */
     73    threadid = pth_self();
     74    return (long) *(long *) &threadid;
    8675}
    8776
    8877void PyThread_exit_thread(void)
    8978{
    90         do_PyThread_exit_thread(0);
     79    dprintf(("PyThread_exit_thread called\n"));
     80    if (!initialized) {
     81        exit(0);
     82    }
    9183}
    92 
    93 void PyThread__exit_thread(void)
    94 {
    95         do_PyThread_exit_thread(1);
    96 }
    97 
    98 #ifndef NO_EXIT_PROG
    99 static void do_PyThread_exit_prog(int status, int no_cleanup)
    100 {
    101         dprintf(("PyThread_exit_prog(%d) called\n", status));
    102         if (!initialized)
    103                 if (no_cleanup)
    104                         _exit(status);
    105                 else
    106                         exit(status);
    107 }
    108 
    109 void PyThread_exit_prog(int status)
    110 {
    111         do_PyThread_exit_prog(status, 0);
    112 }
    113 
    114 void PyThread__exit_prog(int status)
    115 {
    116         do_PyThread_exit_prog(status, 1);
    117 }
    118 #endif /* NO_EXIT_PROG */
    11984
    12085/*
    … …  
    12388PyThread_type_lock PyThread_allocate_lock(void)
    12489{
    125         pth_lock *lock;
    126         int status, error = 0;
     90    pth_lock *lock;
     91    int status, error = 0;
    12792
    128         dprintf(("PyThread_allocate_lock called\n"));
    129         if (!initialized)
    130                 PyThread_init_thread();
     93    dprintf(("PyThread_allocate_lock called\n"));
     94    if (!initialized)
     95        PyThread_init_thread();
    13196
    132         lock = (pth_lock *) malloc(sizeof(pth_lock));
    133         memset((void *)lock, '\0', sizeof(pth_lock));
    134         if (lock) {
    135                 lock->locked = 0;
    136                 status = pth_mutex_init(&lock->mut);
    137                 CHECK_STATUS("pth_mutex_init");
    138                 status = pth_cond_init(&lock->lock_released);
    139                 CHECK_STATUS("pth_cond_init");
    140                 if (error) {
    141                         free((void *)lock);
    142                         lock = NULL;
    143                 }
    144         }
    145         dprintf(("PyThread_allocate_lock() -> %p\n", lock));
    146         return (PyThread_type_lock) lock;
     97    lock = (pth_lock *) malloc(sizeof(pth_lock));
     98    memset((void *)lock, '\0', sizeof(pth_lock));
     99    if (lock) {
     100        lock->locked = 0;
     101        status = pth_mutex_init(&lock->mut);
     102        CHECK_STATUS("pth_mutex_init");
     103        status = pth_cond_init(&lock->lock_released);
     104        CHECK_STATUS("pth_cond_init");
     105        if (error) {
     106            free((void *)lock);
     107            lock = NULL;
     108        }
     109    }
     110    dprintf(("PyThread_allocate_lock() -> %p\n", lock));
     111    return (PyThread_type_lock) lock;
    147112}
    148113
    149114void PyThread_free_lock(PyThread_type_lock lock)
    150115{
    151         pth_lock *thelock = (pth_lock *)lock;
     116    pth_lock *thelock = (pth_lock *)lock;
    152117
    153         dprintf(("PyThread_free_lock(%p) called\n", lock));
     118    dprintf(("PyThread_free_lock(%p) called\n", lock));
    154119
    155         free((void *)thelock);
     120    free((void *)thelock);
    156121}
    157122
    158123int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
    159124{
    160         int success;
    161         pth_lock *thelock = (pth_lock *)lock;
    162         int status, error = 0;
     125    int success;
     126    pth_lock *thelock = (pth_lock *)lock;
     127    int status, error = 0;
    163128
    164         dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
     129    dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
    165130
    166         status = pth_mutex_acquire(&thelock->mut, !waitflag, NULL);
    167         CHECK_STATUS("pth_mutex_acquire[1]");
    168         success = thelock->locked == 0;
    169         if (success) thelock->locked = 1;
     131    status = pth_mutex_acquire(&thelock->mut, !waitflag, NULL);
     132    CHECK_STATUS("pth_mutex_acquire[1]");
     133    success = thelock->locked == 0;
     134    if (success) thelock->locked = 1;
     135    status = pth_mutex_release( &thelock->mut );
     136    CHECK_STATUS("pth_mutex_release[1]");
     137
     138    if ( !success && waitflag ) {
     139        /* continue trying until we get the lock */
     140
     141        /* mut must be locked by me -- part of the condition
     142         * protocol */
     143        status = pth_mutex_acquire( &thelock->mut, !waitflag, NULL );
     144        CHECK_STATUS("pth_mutex_acquire[2]");
     145        while ( thelock->locked ) {
     146            status = pth_cond_await(&thelock->lock_released,
     147                                    &thelock->mut, NULL);
     148            CHECK_STATUS("pth_cond_await");
     149        }
     150        thelock->locked = 1;
    170151        status = pth_mutex_release( &thelock->mut );
    171         CHECK_STATUS("pth_mutex_release[1]");
    172 
    173         if ( !success && waitflag ) {
    174                 /* continue trying until we get the lock */
    175 
    176                 /* mut must be locked by me -- part of the condition
    177                  * protocol */
    178                 status = pth_mutex_acquire( &thelock->mut, !waitflag, NULL );
    179                 CHECK_STATUS("pth_mutex_acquire[2]");
    180                 while ( thelock->locked ) {
    181                         status = pth_cond_await(&thelock->lock_released,
    182                                                 &thelock->mut, NULL);
    183                         CHECK_STATUS("pth_cond_await");
    184                 }
    185                 thelock->locked = 1;
    186                 status = pth_mutex_release( &thelock->mut );
    187                 CHECK_STATUS("pth_mutex_release[2]");
    188                 success = 1;
    189         }
    190         if (error) success = 0;
    191         dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
    192         return success;
     152        CHECK_STATUS("pth_mutex_release[2]");
     153        success = 1;
     154    }
     155    if (error) success = 0;
     156    dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
     157    return success;
    193158}
    194159
    195160void PyThread_release_lock(PyThread_type_lock lock)
    196161{
    197         pth_lock *thelock = (pth_lock *)lock;
    198         int status, error = 0;
     162    pth_lock *thelock = (pth_lock *)lock;
     163    int status, error = 0;
    199164
    200         dprintf(("PyThread_release_lock(%p) called\n", lock));
     165    dprintf(("PyThread_release_lock(%p) called\n", lock));
    201166
    202         status = pth_mutex_acquire( &thelock->mut, 0, NULL );
    203         CHECK_STATUS("pth_mutex_acquire[3]");
     167    status = pth_mutex_acquire( &thelock->mut, 0, NULL );
     168    CHECK_STATUS("pth_mutex_acquire[3]");
    204169
    205         thelock->locked = 0;
     170    thelock->locked = 0;
    206171
    207         status = pth_mutex_release( &thelock->mut );
    208         CHECK_STATUS("pth_mutex_release[3]");
     172    status = pth_mutex_release( &thelock->mut );
     173    CHECK_STATUS("pth_mutex_release[3]");
    209174
    210         /* wake up someone (anyone, if any) waiting on the lock */
    211         status = pth_cond_notify( &thelock->lock_released, 0 );
    212         CHECK_STATUS("pth_cond_notify");
     175    /* wake up someone (anyone, if any) waiting on the lock */
     176    status = pth_cond_notify( &thelock->lock_released, 0 );
     177    CHECK_STATUS("pth_cond_notify");
    213178}
Note: See TracChangeset for help on using the changeset viewer.