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_os2.h

    r2 r391  
    1717/* default thread stack size of 64kB */
    1818#if !defined(THREAD_STACK_SIZE)
    19 #define THREAD_STACK_SIZE       0x10000
    20 #endif
    21 
    22 #define OS2_STACKSIZE(x)        (x ? x : THREAD_STACK_SIZE)
     19#define THREAD_STACK_SIZE       0x10000
     20#endif
     21
     22#define OS2_STACKSIZE(x)        (x ? x : THREAD_STACK_SIZE)
    2323
    2424/*
    … …  
    3636PyThread_start_new_thread(void (*func)(void *), void *arg)
    3737{
    38         int thread_id;
    39 
    40         thread_id = _beginthread(func,
    41                                 NULL,
    42                                 OS2_STACKSIZE(_pythread_stacksize),
    43                                 arg);
    44 
    45         if (thread_id == -1) {
    46                 dprintf(("_beginthread failed. return %ld\n", errno));
    47         }
    48 
    49         return thread_id;
     38    int thread_id;
     39
     40    thread_id = _beginthread(func,
     41                            NULL,
     42                            OS2_STACKSIZE(_pythread_stacksize),
     43                            arg);
     44
     45    if (thread_id == -1) {
     46        dprintf(("_beginthread failed. return %ld\n", errno));
     47    }
     48
     49    return thread_id;
    5050}
    5151
    … …  
    5454{
    5555#if !defined(PYCC_GCC)
    56         PPIB pib;
    57         PTIB tib;
    58 #endif
    59 
    60         if (!initialized)
    61                 PyThread_init_thread();
    62 
    63 #if defined(PYCC_GCC)
    64         return _gettid();
    65 #else
    66         DosGetInfoBlocks(&tib, &pib);
    67         return tib->tib_ptib2->tib2_ultid;
    68 #endif
    69 }
    70 
    71 static void
    72 do_PyThread_exit_thread(int no_cleanup)
    73 {
    74         dprintf(("%ld: PyThread_exit_thread called\n",
    75                  PyThread_get_thread_ident()));
    76         if (!initialized)
    77                 if (no_cleanup)
    78                         _exit(0);
    79                 else
    80                         exit(0);
    81         _endthread();
    82 }
    83 
    84 void
     56    PPIB pib;
     57    PTIB tib;
     58#endif
     59
     60    if (!initialized)
     61        PyThread_init_thread();
     62
     63#if defined(PYCC_GCC)
     64    return _gettid();
     65#else
     66    DosGetInfoBlocks(&tib, &pib);
     67    return tib->tib_ptib2->tib2_ultid;
     68#endif
     69}
     70
     71void
    8572PyThread_exit_thread(void)
    8673{
    87         do_PyThread_exit_thread(0);
    88 }
    89 
    90 void
    91 PyThread__exit_thread(void)
    92 {
    93         do_PyThread_exit_thread(1);
    94 }
    95 
    96 #ifndef NO_EXIT_PROG
    97 static void
    98 do_PyThread_exit_prog(int status, int no_cleanup)
    99 {
    100         dprintf(("PyThread_exit_prog(%d) called\n", status));
    101         if (!initialized)
    102                 if (no_cleanup)
    103                         _exit(status);
    104                 else
    105                         exit(status);
    106 }
    107 
    108 void
    109 PyThread_exit_prog(int status)
    110 {
    111         do_PyThread_exit_prog(status, 0);
    112 }
    113 
    114 void
    115 PyThread__exit_prog(int status)
    116 {
    117         do_PyThread_exit_prog(status, 1);
    118 }
    119 #endif /* NO_EXIT_PROG */
     74    dprintf(("%ld: PyThread_exit_thread called\n",
     75             PyThread_get_thread_ident()));
     76    if (!initialized)
     77        exit(0);
     78    _endthread();
     79}
    12080
    12181/*
    12282 * Lock support.  This is implemented with an event semaphore and critical
    123  * sections to make it behave more like a posix mutex than its OS/2 
     83 * sections to make it behave more like a posix mutex than its OS/2
    12484 * counterparts.
    12585 */
    12686
    12787typedef struct os2_lock_t {
    128         int is_set;
    129         HEV changed;
     88    int is_set;
     89    HEV changed;
    13090} *type_os2_lock;
    13191
    132 PyThread_type_lock 
     92PyThread_type_lock
    13393PyThread_allocate_lock(void)
    13494{
    13595#if defined(PYCC_GCC)
    136         _fmutex *sem = malloc(sizeof(_fmutex));
    137         if (!initialized)
    138                 PyThread_init_thread();
    139         dprintf(("%ld: PyThread_allocate_lock() -> %lx\n",
    140                 PyThread_get_thread_ident(),
    141                 (long)sem));
    142         if (_fmutex_create(sem, 0)) {
    143                 free(sem);
    144                 sem = NULL;
    145         }
    146         return (PyThread_type_lock)sem;
    147 #else
    148         APIRET rc;
    149         type_os2_lock lock = (type_os2_lock)malloc(sizeof(struct os2_lock_t));
    150 
    151         dprintf(("PyThread_allocate_lock called\n"));
    152         if (!initialized)
    153                 PyThread_init_thread();
    154 
    155         lock->is_set = 0;
    156 
    157         DosCreateEventSem(NULL, &lock->changed, 0, 0);
    158 
    159         dprintf(("%ld: PyThread_allocate_lock() -> %p\n",
    160                  PyThread_get_thread_ident(),
    161                 lock->changed));
    162 
    163         return (PyThread_type_lock)lock;
    164 #endif
    165 }
    166 
    167 void 
     96    _fmutex *sem = malloc(sizeof(_fmutex));
     97    if (!initialized)
     98        PyThread_init_thread();
     99    dprintf(("%ld: PyThread_allocate_lock() -> %lx\n",
     100            PyThread_get_thread_ident(),
     101            (long)sem));
     102    if (_fmutex_create(sem, 0)) {
     103        free(sem);
     104        sem = NULL;
     105    }
     106    return (PyThread_type_lock)sem;
     107#else
     108    APIRET rc;
     109    type_os2_lock lock = (type_os2_lock)malloc(sizeof(struct os2_lock_t));
     110
     111    dprintf(("PyThread_allocate_lock called\n"));
     112    if (!initialized)
     113        PyThread_init_thread();
     114
     115    lock->is_set = 0;
     116
     117    DosCreateEventSem(NULL, &lock->changed, 0, 0);
     118
     119    dprintf(("%ld: PyThread_allocate_lock() -> %p\n",
     120             PyThread_get_thread_ident(),
     121            lock->changed));
     122
     123    return (PyThread_type_lock)lock;
     124#endif
     125}
     126
     127void
    168128PyThread_free_lock(PyThread_type_lock aLock)
    169129{
    170130#if !defined(PYCC_GCC)
    171         type_os2_lock lock = (type_os2_lock)aLock;
    172 #endif
    173 
    174         dprintf(("%ld: PyThread_free_lock(%p) called\n",
    175                 PyThread_get_thread_ident(),aLock));
    176 
    177 #if defined(PYCC_GCC)
    178         if (aLock) {
    179                 _fmutex_close((_fmutex *)aLock);
    180                 free((_fmutex *)aLock);
    181         }
    182 #else
    183         DosCloseEventSem(lock->changed);
    184         free(aLock);
     131    type_os2_lock lock = (type_os2_lock)aLock;
     132#endif
     133
     134    dprintf(("%ld: PyThread_free_lock(%p) called\n",
     135            PyThread_get_thread_ident(),aLock));
     136
     137#if defined(PYCC_GCC)
     138    if (aLock) {
     139        _fmutex_close((_fmutex *)aLock);
     140        free((_fmutex *)aLock);
     141    }
     142#else
     143    DosCloseEventSem(lock->changed);
     144    free(aLock);
    185145#endif
    186146}
    … …  
    191151 * and 0 if the lock was not acquired.
    192152 */
    193 int 
     153int
    194154PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
    195155{
    196156#if !defined(PYCC_GCC)
    197         int   done = 0;
    198         ULONG count;
    199         PID   pid = 0;
    200         TID   tid = 0;
    201         type_os2_lock lock = (type_os2_lock)aLock;
    202 #endif
    203 
    204         dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n",
    205                 PyThread_get_thread_ident(),
    206                 aLock,
    207                 waitflag));
    208 
    209 #if defined(PYCC_GCC)
    210         /* always successful if the lock doesn't exist */
    211         if (aLock &&
    212             _fmutex_request((_fmutex *)aLock, waitflag ? 0 : _FMR_NOWAIT))
    213                 return 0;
    214 #else
    215         while (!done) {
    216                 /* if the lock is currently set, we have to wait for
    217                 * the state to change
    218                 */
    219                 if (lock->is_set) {
    220                         if (!waitflag)
    221                                 return 0;
    222                         DosWaitEventSem(lock->changed, SEM_INDEFINITE_WAIT);
    223                 }
    224 
    225                 /* enter a critical section and try to get the semaphore.  If
    226                 * it is still locked, we will try again.
    227                 */
    228                 if (DosEnterCritSec())
    229                         return 0;
    230 
    231                 if (!lock->is_set) {
    232                         lock->is_set = 1;
    233                         DosResetEventSem(lock->changed, &count);
    234                         done = 1;
    235                 }
    236 
    237                 DosExitCritSec();
    238         }
    239 #endif
    240 
    241         return 1;
     157    int   done = 0;
     158    ULONG count;
     159    PID   pid = 0;
     160    TID   tid = 0;
     161    type_os2_lock lock = (type_os2_lock)aLock;
     162#endif
     163
     164    dprintf(("%ld: PyThread_acquire_lock(%p, %d) called\n",
     165            PyThread_get_thread_ident(),
     166            aLock,
     167            waitflag));
     168
     169#if defined(PYCC_GCC)
     170    /* always successful if the lock doesn't exist */
     171    if (aLock &&
     172        _fmutex_request((_fmutex *)aLock, waitflag ? 0 : _FMR_NOWAIT))
     173        return 0;
     174#else
     175    while (!done) {
     176        /* if the lock is currently set, we have to wait for
     177        * the state to change
     178        */
     179        if (lock->is_set) {
     180            if (!waitflag)
     181                return 0;
     182            DosWaitEventSem(lock->changed, SEM_INDEFINITE_WAIT);
     183        }
     184
     185        /* enter a critical section and try to get the semaphore.  If
     186        * it is still locked, we will try again.
     187        */
     188        if (DosEnterCritSec())
     189            return 0;
     190
     191        if (!lock->is_set) {
     192            lock->is_set = 1;
     193            DosResetEventSem(lock->changed, &count);
     194            done = 1;
     195        }
     196
     197        DosExitCritSec();
     198    }
     199#endif
     200
     201    return 1;
    242202}
    243203
    … …  
    246206{
    247207#if !defined(PYCC_GCC)
    248         type_os2_lock lock = (type_os2_lock)aLock;
    249 #endif
    250 
    251         dprintf(("%ld: PyThread_release_lock(%p) called\n",
    252                 PyThread_get_thread_ident(),
    253                 aLock));
    254 
    255 #if defined(PYCC_GCC)
    256         if (aLock)
    257                 _fmutex_release((_fmutex *)aLock);
    258 #else
    259         if (!lock->is_set) {
    260                 dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
    261                         PyThread_get_thread_ident(),
    262                         aLock,
    263                         GetLastError()));
    264                 return;
    265         }
    266 
    267         if (DosEnterCritSec()) {
    268                 dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
    269                         PyThread_get_thread_ident(),
    270                         aLock,
    271                         GetLastError()));
    272                 return;
    273         }
    274 
    275         lock->is_set = 0;
    276         DosPostEventSem(lock->changed);
    277 
    278         DosExitCritSec();
     208    type_os2_lock lock = (type_os2_lock)aLock;
     209#endif
     210
     211    dprintf(("%ld: PyThread_release_lock(%p) called\n",
     212            PyThread_get_thread_ident(),
     213            aLock));
     214
     215#if defined(PYCC_GCC)
     216    if (aLock)
     217        _fmutex_release((_fmutex *)aLock);
     218#else
     219    if (!lock->is_set) {
     220        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
     221                PyThread_get_thread_ident(),
     222                aLock,
     223                GetLastError()));
     224        return;
     225    }
     226
     227    if (DosEnterCritSec()) {
     228        dprintf(("%ld: Could not PyThread_release_lock(%p) error: %l\n",
     229                PyThread_get_thread_ident(),
     230                aLock,
     231                GetLastError()));
     232        return;
     233    }
     234
     235    lock->is_set = 0;
     236    DosPostEventSem(lock->changed);
     237
     238    DosExitCritSec();
    279239#endif
    280240}
    281241
    282242/* minimum/maximum thread stack sizes supported */
    283 #define THREAD_MIN_STACKSIZE    0x8000          /* 32kB */
    284 #define THREAD_MAX_STACKSIZE    0x2000000       /* 32MB */
     243#define THREAD_MIN_STACKSIZE    0x8000          /* 32kB */
     244#define THREAD_MAX_STACKSIZE    0x2000000       /* 32MB */
    285245
    286246/* set the thread stack size.
    … …  
    290250_pythread_os2_set_stacksize(size_t size)
    291251{
    292         /* set to default */
    293         if (size == 0) {
    294                 _pythread_stacksize = 0;
    295                 return 0;
    296         }
    297 
    298         /* valid range? */
    299         if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
    300                 _pythread_stacksize = size;
    301                 return 0;
    302         }
    303 
    304         return -1;
    305 }
    306 
    307 #define THREAD_SET_STACKSIZE(x) _pythread_os2_set_stacksize(x)
     252    /* set to default */
     253    if (size == 0) {
     254        _pythread_stacksize = 0;
     255        return 0;
     256    }
     257
     258    /* valid range? */
     259    if (size >= THREAD_MIN_STACKSIZE && size < THREAD_MAX_STACKSIZE) {
     260        _pythread_stacksize = size;
     261        return 0;
     262    }
     263
     264    return -1;
     265}
     266
     267#define THREAD_SET_STACKSIZE(x) _pythread_os2_set_stacksize(x)
Note: See TracChangeset for help on using the changeset viewer.