home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 15 / AACD15.ISO / AACD / Programming / Python2 / Python20_source / Python / thread_lwp.h < prev    next >
Encoding:
C/C++ Source or Header  |  2000-10-25  |  3.8 KB  |  181 lines
  1.  
  2. #include <stdlib.h>
  3. #include <lwp/lwp.h>
  4. #include <lwp/stackdep.h>
  5.  
  6. #define STACKSIZE    1000    /* stacksize for a thread */
  7. #define NSTACKS        2    /* # stacks to be put in cache initially */
  8.  
  9. struct lock {
  10.     int lock_locked;
  11.     cv_t lock_condvar;
  12.     mon_t lock_monitor;
  13. };
  14.  
  15.  
  16. /*
  17.  * Initialization.
  18.  */
  19. static void PyThread__init_thread(void)
  20. {
  21.     lwp_setstkcache(STACKSIZE, NSTACKS);
  22. }
  23.  
  24. /*
  25.  * Thread support.
  26.  */
  27.  
  28.  
  29. int PyThread_start_new_thread(void (*func)(void *), void *arg)
  30. {
  31.     thread_t tid;
  32.     int success;
  33.     dprintf(("PyThread_start_new_thread called\n"));
  34.     if (!initialized)
  35.         PyThread_init_thread();
  36.     success = lwp_create(&tid, func, MINPRIO, 0, lwp_newstk(), 1, arg);
  37.     return success < 0 ? 0 : 1;
  38. }
  39.  
  40. long PyThread_get_thread_ident(void)
  41. {
  42.     thread_t tid;
  43.     if (!initialized)
  44.         PyThread_init_thread();
  45.     if (lwp_self(&tid) < 0)
  46.         return -1;
  47.     return tid.thread_id;
  48. }
  49.  
  50. static void do_PyThread_exit_thread(int no_cleanup)
  51. {
  52.     dprintf(("PyThread_exit_thread called\n"));
  53.     if (!initialized)
  54.         if (no_cleanup)
  55.             _exit(0);
  56.         else
  57.             exit(0);
  58.     lwp_destroy(SELF);
  59. }
  60.  
  61. void PyThread_exit_thread(void)
  62. {
  63.     do_PyThread_exit_thread(0);
  64. }
  65.  
  66. void PyThread__exit_thread(void)
  67. {
  68.     do_PyThread_exit_thread(1);
  69. }
  70.  
  71. #ifndef NO_EXIT_PROG
  72. static void do_PyThread_exit_prog(int status, int no_cleanup)
  73. {
  74.     dprintf(("PyThread_exit_prog(%d) called\n", status));
  75.     if (!initialized)
  76.         if (no_cleanup)
  77.             _exit(status);
  78.         else
  79.             exit(status);
  80.     pod_exit(status);
  81. }
  82.  
  83. void PyThread_exit_prog(int status)
  84. {
  85.     do_PyThread_exit_prog(status, 0);
  86. }
  87.  
  88. void PyThread__exit_prog(int status)
  89. {
  90.     do_PyThread_exit_prog(status, 1);
  91. }
  92. #endif /* NO_EXIT_PROG */
  93.  
  94. /*
  95.  * Lock support.
  96.  */
  97. PyThread_type_lock PyThread_allocate_lock(void)
  98. {
  99.     struct lock *lock;
  100.     extern char *malloc(size_t);
  101.  
  102.     dprintf(("PyThread_allocate_lock called\n"));
  103.     if (!initialized)
  104.         PyThread_init_thread();
  105.  
  106.     lock = (struct lock *) malloc(sizeof(struct lock));
  107.     lock->lock_locked = 0;
  108.     (void) mon_create(&lock->lock_monitor);
  109.     (void) cv_create(&lock->lock_condvar, lock->lock_monitor);
  110.     dprintf(("PyThread_allocate_lock() -> %p\n", lock));
  111.     return (PyThread_type_lock) lock;
  112. }
  113.  
  114. void PyThread_free_lock(PyThread_type_lock lock)
  115. {
  116.     dprintf(("PyThread_free_lock(%p) called\n", lock));
  117.     mon_destroy(((struct lock *) lock)->lock_monitor);
  118.     free((char *) lock);
  119. }
  120.  
  121. int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
  122. {
  123.     int success;
  124.  
  125.     dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
  126.     success = 0;
  127.  
  128.     (void) mon_enter(((struct lock *) lock)->lock_monitor);
  129.     if (waitflag)
  130.         while (((struct lock *) lock)->lock_locked)
  131.             cv_wait(((struct lock *) lock)->lock_condvar);
  132.     if (!((struct lock *) lock)->lock_locked) {
  133.         success = 1;
  134.         ((struct lock *) lock)->lock_locked = 1;
  135.     }
  136.     cv_broadcast(((struct lock *) lock)->lock_condvar);
  137.     mon_exit(((struct lock *) lock)->lock_monitor);
  138.     dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
  139.     return success;
  140. }
  141.  
  142. void PyThread_release_lock(PyThread_type_lock lock)
  143. {
  144.     dprintf(("PyThread_release_lock(%p) called\n", lock));
  145.     (void) mon_enter(((struct lock *) lock)->lock_monitor);
  146.     ((struct lock *) lock)->lock_locked = 0;
  147.     cv_broadcast(((struct lock *) lock)->lock_condvar);
  148.     mon_exit(((struct lock *) lock)->lock_monitor);
  149. }
  150.  
  151. /*
  152.  * Semaphore support.
  153.  */
  154. PyThread_type_sema PyThread_allocate_sema(int value)
  155. {
  156.     PyThread_type_sema sema = 0;
  157.     dprintf(("PyThread_allocate_sema called\n"));
  158.     if (!initialized)
  159.         PyThread_init_thread();
  160.  
  161.     dprintf(("PyThread_allocate_sema() -> %p\n",  sema));
  162.     return (PyThread_type_sema) sema;
  163. }
  164.  
  165. void PyThread_free_sema(PyThread_type_sema sema)
  166. {
  167.     dprintf(("PyThread_free_sema(%p) called\n",  sema));
  168. }
  169.  
  170. int PyThread_down_sema(PyThread_type_sema sema, int waitflag)
  171. {
  172.     dprintf(("PyThread_down_sema(%p, %d) called\n",  sema, waitflag));
  173.     dprintf(("PyThread_down_sema(%p) return\n",  sema));
  174.     return -1;
  175. }
  176.  
  177. void PyThread_up_sema(PyThread_type_sema sema)
  178. {
  179.     dprintf(("PyThread_up_sema(%p)\n",  sema));
  180. }
  181.