Python/thread_nt.h

   1 /***********************************************************
   2 Copyright 1991-1995 by Stichting Mathematisch Centrum, Amsterdam,
   3 The Netherlands.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Stichting Mathematisch
  12 Centrum or CWI or Corporation for National Research Initiatives or
  13 CNRI not be used in advertising or publicity pertaining to
  14 distribution of the software without specific, written prior
  15 permission.
  16
  17 While CWI is the initial source for this software, a modified version
  18 is made available by the Corporation for National Research Initiatives
  19 (CNRI) at the Internet address ftp://ftp.python.org.
  20
  21 STICHTING MATHEMATISCH CENTRUM AND CNRI DISCLAIM ALL WARRANTIES WITH
  22 REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
  23 MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL STICHTING MATHEMATISCH
  24 CENTRUM OR CNRI BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  25 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
  26 PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  27 TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  28 PERFORMANCE OF THIS SOFTWARE.
  29
  30 ******************************************************************/
  31
  32 /* This code implemented by Dag.Gruneau@elsa.preseco.comm.se */
  33
  34 #include <windows.h>
  35 #include <limits.h>
  36 #include <process.h>
  37
  38 long PyThread_get_thread_ident(void);
  39
  40 /*
  41  * Change all headers to pure ANSI as no one will use K&R style on an
  42  * NT
  43  */
  44
  45 /*
  46  * Initialization of the C package, should not be needed.
  47  */
  48 static void PyThread__init_thread(void)
  49 {
  50 }
  51
  52 /*
  53  * Thread support.
  54  */
  55 int PyThread_start_new_thread(void (*func)(void *), void *arg)
  56 {
  57         long rv;
  58         int success = 0;
  59
  60         dprintf(("%ld: PyThread_start_new_thread called\n", PyThread_get_thread_ident()));
  61         if (!initialized)
  62                 PyThread_init_thread();
  63
  64         rv = _beginthread(func, 0, arg); /* use default stack size */
  65
  66         if (rv != -1) {
  67                 success = 1;
  68                 dprintf(("%ld: PyThread_start_new_thread succeeded: %ld\n", PyThread_get_thread_ident(), aThreadId));
  69         }
  70
  71         return success;
  72 }
  73
  74 /*
  75  * Return the thread Id instead of an handle. The Id is said to uniquely identify the
  76  * thread in the system
  77  */
  78 long PyThread_get_thread_ident(void)
  79 {
  80         if (!initialized)
  81                 PyThread_init_thread();
  82
  83         return GetCurrentThreadId();
  84 }
  85
  86 static void do_PyThread_exit_thread(int no_cleanup)
  87 {
  88         dprintf(("%ld: PyThread_exit_thread called\n", PyThread_get_thread_ident()));
  89         if (!initialized)
  90                 if (no_cleanup)
  91                         _exit(0);
  92                 else
  93                         exit(0);
  94         _endthread();
  95 }
  96
  97 void PyThread_exit_thread(void)
  98 {
  99         do_PyThread_exit_thread(0);
 100 }
 101
 102 void PyThread__exit_thread(void)
 103 {
 104         do_PyThread_exit_thread(1);
 105 }
 106
 107 #ifndef NO_EXIT_PROG
 108 static void do_PyThread_exit_prog(int status, int no_cleanup)
 109 {
 110         dprintf(("PyThread_exit_prog(%d) called\n", status));
 111         if (!initialized)
 112                 if (no_cleanup)
 113                         _exit(status);
 114                 else
 115                         exit(status);
 116 }
 117
 118 void PyThread_exit_prog(int status)
 119 {
 120         do_PyThread_exit_prog(status, 0);
 121 }
 122
 123 void PyThread__exit_prog _P1(int status)
 124 {
 125         do_PyThread_exit_prog(status, 1);
 126 }
 127 #endif /* NO_EXIT_PROG */
 128
 129 /*
 130  * Lock support. It has too be implemented as semaphores.
 131  * I [Dag] tried to implement it with mutex but I could find a way to
 132  * tell whether a thread already own the lock or not.
 133  */
 134 PyThread_type_lock PyThread_allocate_lock(void)
 135 {
 136         HANDLE aLock;
 137
 138         dprintf(("PyThread_allocate_lock called\n"));
 139         if (!initialized)
 140                 PyThread_init_thread();
 141
 142                 aLock = CreateSemaphore(NULL,           /* Security attributes          */
 143                          1,                     /* Initial value                */
 144                          1,                     /* Maximum value                */
 145                          NULL);
 146   /* Name of semaphore            */
 147
 148         dprintf(("%ld: PyThread_allocate_lock() -> %lx\n", PyThread_get_thread_ident(), (long)aLock));
 149
 150         return (PyThread_type_lock) aLock;
 151 }
 152
 153 void PyThread_free_lock(PyThread_type_lock aLock)
 154 {
 155         dprintf(("%ld: PyThread_free_lock(%lx) called\n", PyThread_get_thread_ident(),(long)aLock));
 156
 157         CloseHandle((HANDLE) aLock);
 158 }
 159
 160 /*
 161  * Return 1 on success if the lock was acquired
 162  *
 163  * and 0 if the lock was not acquired. This means a 0 is returned
 164  * if the lock has already been acquired by this thread!
 165  */
 166 int PyThread_acquire_lock(PyThread_type_lock aLock, int waitflag)
 167 {
 168         int success = 1;
 169         DWORD waitResult;
 170
 171         dprintf(("%ld: PyThread_acquire_lock(%lx, %d) called\n", PyThread_get_thread_ident(),(long)aLock, waitflag));
 172
 173         waitResult = WaitForSingleObject((HANDLE) aLock, (waitflag == 1 ? INFINITE : 0));
 174
 175         if (waitResult != WAIT_OBJECT_0) {
 176                 success = 0;    /* We failed */
 177         }
 178
 179         dprintf(("%ld: PyThread_acquire_lock(%lx, %d) -> %d\n", PyThread_get_thread_ident(),(long)aLock, waitflag, success));
 180
 181         return success;
 182 }
 183
 184 void PyThread_release_lock(PyThread_type_lock aLock)
 185 {
 186         dprintf(("%ld: PyThread_release_lock(%lx) called\n", PyThread_get_thread_ident(),(long)aLock));
 187
 188         if (!ReleaseSemaphore(
 189                         (HANDLE) aLock,                         /* Handle of semaphore                          */
 190                         1,                                      /* increment count by one                       */
 191                         NULL))                                  /* not interested in previous count             */
 192                 {
 193                 dprintf(("%ld: Could not PyThread_release_lock(%lx) error: %l\n", PyThread_get_thread_ident(), (long)aLock, GetLastError()));
 194                 }
 195 }
 196
 197 /*
 198  * Semaphore support.
 199  */
 200 PyThread_type_sema PyThread_allocate_sema(int value)
 201 {
 202         HANDLE aSemaphore;
 203
 204         dprintf(("%ld: PyThread_allocate_sema called\n", PyThread_get_thread_ident()));
 205         if (!initialized)
 206                 PyThread_init_thread();
 207
 208         aSemaphore = CreateSemaphore( NULL,           /* Security attributes          */
 209                                   value,          /* Initial value                */
 210                                   INT_MAX,        /* Maximum value                */
 211                                   NULL);          /* Name of semaphore            */
 212
 213         dprintf(("%ld: PyThread_allocate_sema() -> %lx\n", PyThread_get_thread_ident(), (long)aSemaphore));
 214
 215         return (PyThread_type_sema) aSemaphore;
 216 }
 217
 218 void PyThread_free_sema(PyThread_type_sema aSemaphore)
 219 {
 220         dprintf(("%ld: PyThread_free_sema(%lx) called\n", PyThread_get_thread_ident(), (long)aSemaphore));
 221
 222         CloseHandle((HANDLE) aSemaphore);
 223 }
 224
 225 /*
 226   XXX must do something about waitflag
 227  */
 228 int PyThread_down_sema(PyThread_type_sema aSemaphore, int waitflag)
 229 {
 230         DWORD waitResult;
 231
 232         dprintf(("%ld: PyThread_down_sema(%lx) called\n", PyThread_get_thread_ident(), (long)aSemaphore));
 233
 234         waitResult = WaitForSingleObject( (HANDLE) aSemaphore, INFINITE);
 235
 236         dprintf(("%ld: PyThread_down_sema(%lx) return: %l\n", PyThread_get_thread_ident(),(long) aSemaphore, waitResult));
 237         return 0;
 238 }
 239
 240 void PyThread_up_sema(PyThread_type_sema aSemaphore)
 241 {
 242         ReleaseSemaphore(
 243                 (HANDLE) aSemaphore,            /* Handle of semaphore                          */
 244                 1,                              /* increment count by one                       */
 245                 NULL);                          /* not interested in previous count             */
 246
 247         dprintf(("%ld: PyThread_up_sema(%lx)\n", PyThread_get_thread_ident(), (long)aSemaphore));
 248 }