toolchain/gcc/libjava/win32-threads.cc

   1 // win32-threads.cc - interface between libjava and Win32 threads.
   2
   3 /* Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 Free Software
   4    Foundation, Inc.
   5
   6    This file is part of libgcj.
   7
   8 This software is copyrighted work licensed under the terms of the
   9 Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
  10 details.  */
  11
  12 #include <config.h>
  13
  14 // If we're using the Boehm GC, then we need to override some of the
  15 // thread primitives.  This is fairly gross.
  16 #ifdef HAVE_BOEHM_GC
  17 extern "C"
  18 {
  19 #include <gc.h>
  20 // <windows.h> #define's STRICT, which conflicts with Modifier.h
  21 #undef STRICT
  22 };
  23 #endif /* HAVE_BOEHM_GC */
  24
  25 #include <gcj/cni.h>
  26 #include <jvm.h>
  27 #include <java/lang/Thread.h>
  28 #include <java/lang/System.h>
  29
  30 #include <errno.h>
  31
  32 #ifndef ETIMEDOUT
  33 #define ETIMEDOUT 116
  34 #endif
  35
  36 // This is used to implement thread startup.
  37 struct starter
  38 {
  39   _Jv_ThreadStartFunc *method;
  40   _Jv_Thread_t *data;
  41 };
  42
  43 // Controls access to the variable below
  44 static HANDLE daemon_mutex;
  45 static HANDLE daemon_cond;
  46 // Number of non-daemon threads - _Jv_ThreadWait returns when this is 0
  47 static int non_daemon_count;
  48
  49 // TLS key get Java object representing the thread
  50 DWORD _Jv_ThreadKey;
  51 // TLS key to get _Jv_Thread_t* representing the thread
  52 DWORD _Jv_ThreadDataKey;
  53
  54 //
  55 // These are the flags that can appear in _Jv_Thread_t.
  56 //
  57
  58 // Thread started.
  59 #define FLAG_START   0x01
  60 // Thread is daemon.
  61 #define FLAG_DAEMON  0x02
  62
  63 //
  64 // Condition variables.
  65 //
  66
  67 // we do lazy creation of Events since CreateEvent() is insanely
  68 // expensive, and because the rest of libgcj will call _Jv_CondInit
  69 // when only a mutex is needed.
  70
  71 inline void
  72 ensure_condvar_initialized(_Jv_ConditionVariable_t *cv)
  73 {
  74   if (cv->ev[0] == 0)
  75     {
  76       cv->ev[0] = CreateEvent (NULL, 0, 0, NULL);
  77       if (cv->ev[0] == 0) JvFail("CreateEvent() failed");
  78
  79       cv->ev[1] = CreateEvent (NULL, 1, 0, NULL);
  80       if (cv->ev[1] == 0) JvFail("CreateEvent() failed");
  81     }
  82 }
  83
  84 inline void
  85 ensure_interrupt_event_initialized(HANDLE& rhEvent)
  86 {
  87   if (!rhEvent)
  88     {
  89       rhEvent = CreateEvent (NULL, 0, 0, NULL);
  90       if (!rhEvent) JvFail("CreateEvent() failed");
  91     }
  92 }
  93
  94 // Reimplementation of the general algorithm described at
  95 // http://www.cs.wustl.edu/~schmidt/win32-cv-1.html (isomorphic to
  96 // 3.2, not a cut-and-paste).
  97
  98 int
  99 _Jv_CondWait(_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu, jlong millis, jint nanos)
 100 {
 101   if (mu->owner != GetCurrentThreadId ( ))
 102     return _JV_NOT_OWNER;
 103
 104   _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
 105   java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
 106
 107   // Now that we hold the interrupt mutex, check if this thread has been
 108   // interrupted already.
 109   EnterCriticalSection (&current->interrupt_mutex);
 110   ensure_interrupt_event_initialized (current->interrupt_event);
 111   jboolean interrupted = current_obj->interrupt_flag;
 112   LeaveCriticalSection (&current->interrupt_mutex);
 113
 114   if (interrupted)
 115     {
 116       return _JV_INTERRUPTED;
 117     }
 118
 119   EnterCriticalSection (&cv->count_mutex);
 120   ensure_condvar_initialized (cv);
 121   cv->blocked_count++;
 122   LeaveCriticalSection (&cv->count_mutex);
 123
 124   DWORD time;
 125   if ((millis == 0) && (nanos > 0)) time = 1;
 126   else if (millis == 0) time = INFINITE;
 127   else time = millis;
 128
 129   // Record the current lock depth, so it can be restored
 130   // when we reacquire it.
 131   int count = mu->refcount;
 132   int curcount = count;
 133
 134   // Call _Jv_MutexUnlock repeatedly until this thread
 135   // has completely released the monitor.
 136   while (curcount > 0)
 137     {
 138       _Jv_MutexUnlock (mu);
 139       --curcount;
 140     }
 141
 142   // Set up our array of three events:
 143   // - the auto-reset event (for notify())
 144   // - the manual-reset event (for notifyAll())
 145   // - the interrupt event (for interrupt())
 146   // We wait for any one of these to be signaled.
 147   HANDLE arh[3];
 148   arh[0] = cv->ev[0];
 149   arh[1] = cv->ev[1];
 150   arh[2] = current->interrupt_event;
 151   DWORD rval = WaitForMultipleObjects (3, arh, 0, time);
 152
 153   EnterCriticalSection (&current->interrupt_mutex);
 154
 155   // If we were unblocked by the third event (our thread's interrupt
 156   // event), set the thread's interrupt flag. I think this sanity
 157   // check guards against someone resetting our interrupt flag
 158   // in the time between when interrupt_mutex is released in
 159   // _Jv_ThreadInterrupt and the interval of time between the
 160   // WaitForMultipleObjects call we just made and our acquisition
 161   // of interrupt_mutex.
 162   if (rval == (WAIT_OBJECT_0 + 2))
 163     current_obj->interrupt_flag = true;
 164
 165   interrupted = current_obj->interrupt_flag;
 166   LeaveCriticalSection (&current->interrupt_mutex);
 167
 168   EnterCriticalSection(&cv->count_mutex);
 169   cv->blocked_count--;
 170   // If we were unblocked by the second event (the broadcast one)
 171   // and nobody is left, then reset the event.
 172   int last_waiter = (rval == (WAIT_OBJECT_0 + 1)) && (cv->blocked_count == 0);
 173   LeaveCriticalSection(&cv->count_mutex);
 174
 175   if (last_waiter)
 176     ResetEvent (cv->ev[1]);
 177
 178   // Call _Jv_MutexLock repeatedly until the mutex's refcount is the
 179   // same as before we originally released it.
 180   while (curcount < count)
 181     {
 182       _Jv_MutexLock (mu);
 183       ++curcount;
 184     }
 185
 186   return interrupted ? _JV_INTERRUPTED : 0;
 187 }
 188
 189 void
 190 _Jv_CondInit (_Jv_ConditionVariable_t *cv)
 191 {
 192   // we do lazy creation of Events since CreateEvent() is insanely expensive
 193   cv->ev[0] = 0;
 194   InitializeCriticalSection (&cv->count_mutex);
 195   cv->blocked_count = 0;
 196 }
 197
 198 void
 199 _Jv_CondDestroy (_Jv_ConditionVariable_t *cv)
 200 {
 201   if (cv->ev[0] != 0)
 202     {
 203       CloseHandle (cv->ev[0]);
 204       CloseHandle (cv->ev[1]);
 205
 206       cv->ev[0] = 0;
 207     }
 208
 209   DeleteCriticalSection (&cv->count_mutex);
 210 }
 211
 212 int
 213 _Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
 214 {
 215   if (mu->owner != GetCurrentThreadId ( ))
 216     return _JV_NOT_OWNER;
 217
 218   EnterCriticalSection (&cv->count_mutex);
 219   ensure_condvar_initialized (cv);
 220   int somebody_is_blocked = cv->blocked_count > 0;
 221   LeaveCriticalSection (&cv->count_mutex);
 222
 223   if (somebody_is_blocked)
 224     SetEvent (cv->ev[0]);
 225
 226   return 0;
 227 }
 228
 229 int
 230 _Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
 231 {
 232   if (mu->owner != GetCurrentThreadId ( ))
 233     return _JV_NOT_OWNER;
 234
 235   EnterCriticalSection (&cv->count_mutex);
 236   ensure_condvar_initialized (cv);
 237   int somebody_is_blocked = cv->blocked_count > 0;
 238   LeaveCriticalSection (&cv->count_mutex);
 239
 240   if (somebody_is_blocked)
 241     SetEvent (cv->ev[1]);
 242
 243   return 0;
 244 }
 245
 246 //
 247 // Threads.
 248 //
 249
 250 void
 251 _Jv_InitThreads (void)
 252 {
 253   _Jv_ThreadKey = TlsAlloc();
 254   _Jv_ThreadDataKey = TlsAlloc();
 255   daemon_mutex = CreateMutex (NULL, 0, NULL);
 256   daemon_cond = CreateEvent (NULL, 1, 0, NULL);
 257   non_daemon_count = 0;
 258 }
 259
 260 _Jv_Thread_t *
 261 _Jv_ThreadInitData (java::lang::Thread* obj)
 262 {
 263   _Jv_Thread_t *data = (_Jv_Thread_t*)_Jv_Malloc(sizeof(_Jv_Thread_t));
 264   data->flags = 0;
 265   data->thread_obj = obj;
 266   data->interrupt_event = 0;
 267   InitializeCriticalSection (&data->interrupt_mutex);
 268
 269   return data;
 270 }
 271
 272 void
 273 _Jv_ThreadDestroyData (_Jv_Thread_t *data)
 274 {
 275   DeleteCriticalSection (&data->interrupt_mutex);
 276   if (data->interrupt_event)
 277     CloseHandle(data->interrupt_event);
 278   _Jv_Free(data);
 279 }
 280
 281 void
 282 _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
 283 {
 284   int actual = THREAD_PRIORITY_NORMAL;
 285
 286   if (data->flags & FLAG_START)
 287     {
 288       switch (prio)
 289         {
 290           case 10:
 291             actual = THREAD_PRIORITY_TIME_CRITICAL;
 292             break;
 293           case 9:
 294             actual = THREAD_PRIORITY_HIGHEST;
 295             break;
 296           case 8:
 297           case 7:
 298             actual = THREAD_PRIORITY_ABOVE_NORMAL;
 299             break;
 300           case 6:
 301           case 5:
 302             actual = THREAD_PRIORITY_NORMAL;
 303             break;
 304           case 4:
 305           case 3:
 306             actual = THREAD_PRIORITY_BELOW_NORMAL;
 307             break;
 308           case 2:
 309             actual = THREAD_PRIORITY_LOWEST;
 310             break;
 311           case 1:
 312             actual = THREAD_PRIORITY_IDLE;
 313             break;
 314         }
 315       SetThreadPriority(data->handle, actual);
 316     }
 317 }
 318
 319 void
 320 _Jv_ThreadRegister (_Jv_Thread_t *data)
 321 {
 322   TlsSetValue (_Jv_ThreadKey, data->thread_obj);
 323   TlsSetValue (_Jv_ThreadDataKey, data);
 324 }
 325
 326 void
 327 _Jv_ThreadUnRegister ()
 328 {
 329   TlsSetValue (_Jv_ThreadKey, NULL);
 330   TlsSetValue (_Jv_ThreadDataKey, NULL);
 331 }
 332
 333 // This function is called when a thread is started.  We don't arrange
 334 // to call the `run' method directly, because this function must
 335 // return a value.
 336 static DWORD WINAPI
 337 really_start (void* x)
 338 {
 339   struct starter *info = (struct starter *) x;
 340
 341   _Jv_ThreadRegister (info->data);
 342
 343   info->method (info->data->thread_obj);
 344
 345   if (! (info->data->flags & FLAG_DAEMON))
 346     {
 347       WaitForSingleObject (daemon_mutex, INFINITE);
 348       non_daemon_count--;
 349       if (! non_daemon_count)
 350         SetEvent (daemon_cond);
 351       ReleaseMutex (daemon_mutex);
 352     }
 353
 354   return 0;
 355 }
 356
 357 void
 358 _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data, _Jv_ThreadStartFunc *meth)
 359 {
 360   DWORD id;
 361   struct starter *info;
 362
 363   // Do nothing if thread has already started
 364   if (data->flags & FLAG_START)
 365     return;
 366   data->flags |= FLAG_START;
 367
 368   // FIXME: handle marking the info object for GC.
 369   info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
 370   info->method = meth;
 371   info->data = data;
 372
 373   if (! thread->isDaemon ())
 374     {
 375       WaitForSingleObject (daemon_mutex, INFINITE);
 376       non_daemon_count++;
 377       ReleaseMutex (daemon_mutex);
 378     }
 379   else
 380     data->flags |= FLAG_DAEMON;
 381
 382   GC_CreateThread(NULL, 0, really_start, info, 0, &id);
 383   _Jv_ThreadSetPriority(data, thread->getPriority());
 384 }
 385
 386 void
 387 _Jv_ThreadWait (void)
 388 {
 389   WaitForSingleObject (daemon_mutex, INFINITE);
 390   if (non_daemon_count)
 391     {
 392       ReleaseMutex (daemon_mutex);
 393       WaitForSingleObject (daemon_cond, INFINITE);
 394     }
 395 }
 396
 397 //
 398 // Interrupt support
 399 //
 400
 401 HANDLE
 402 _Jv_Win32GetInterruptEvent (void)
 403 {
 404   _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
 405   EnterCriticalSection (&current->interrupt_mutex);
 406   ensure_interrupt_event_initialized (current->interrupt_event);
 407   HANDLE hEvent = current->interrupt_event;
 408   LeaveCriticalSection (&current->interrupt_mutex);
 409   return hEvent;
 410 }
 411
 412 void
 413 _Jv_ThreadInterrupt (_Jv_Thread_t *data)
 414 {
 415   EnterCriticalSection (&data->interrupt_mutex);
 416   ensure_interrupt_event_initialized (data->interrupt_event);
 417   data->thread_obj->interrupt_flag = true;
 418   SetEvent (data->interrupt_event);
 419   LeaveCriticalSection (&data->interrupt_mutex);
 420 }