Daily bump.
[official-gcc.git] / libjava / posix-threads.cc
blobe92348bcc2cc078bdb768e9ba23c1c6c7ccda1b5
1 // posix-threads.cc - interface between libjava and POSIX threads.
3 /* Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation
5 This file is part of libgcj.
7 This software is copyrighted work licensed under the terms of the
8 Libgcj License. Please consult the file "LIBGCJ_LICENSE" for
9 details. */
11 // TO DO:
12 // * Document signal handling limitations
14 #include <config.h>
16 // If we're using the Boehm GC, then we need to override some of the
17 // thread primitives. This is fairly gross.
18 #ifdef HAVE_BOEHM_GC
19 #include <gc.h>
20 #endif /* HAVE_BOEHM_GC */
22 #include <stdlib.h>
23 #include <time.h>
24 #include <signal.h>
25 #include <errno.h>
26 #include <limits.h>
28 #include <gcj/cni.h>
29 #include <jvm.h>
30 #include <java/lang/Thread.h>
31 #include <java/lang/System.h>
32 #include <java/lang/Long.h>
33 #include <java/lang/OutOfMemoryError.h>
35 // This is used to implement thread startup.
36 struct starter
38 _Jv_ThreadStartFunc *method;
39 _Jv_Thread_t *data;
42 // This is the key used to map from the POSIX thread value back to the
43 // Java object representing the thread. The key is global to all
44 // threads, so it is ok to make it a global here.
45 pthread_key_t _Jv_ThreadKey;
47 // This is the key used to map from the POSIX thread value back to the
48 // _Jv_Thread_t* representing the thread.
49 pthread_key_t _Jv_ThreadDataKey;
51 // We keep a count of all non-daemon threads which are running. When
52 // this reaches zero, _Jv_ThreadWait returns.
53 static pthread_mutex_t daemon_mutex;
54 static pthread_cond_t daemon_cond;
55 static int non_daemon_count;
57 // The signal to use when interrupting a thread.
58 #if defined(LINUX_THREADS) || defined(FREEBSD_THREADS)
59 // LinuxThreads (prior to glibc 2.1) usurps both SIGUSR1 and SIGUSR2.
60 // GC on FreeBSD uses both SIGUSR1 and SIGUSR2.
61 # define INTR SIGHUP
62 #else /* LINUX_THREADS */
63 # define INTR SIGUSR2
64 #endif /* LINUX_THREADS */
67 // These are the flags that can appear in _Jv_Thread_t.
70 // Thread started.
71 #define FLAG_START 0x01
72 // Thread is daemon.
73 #define FLAG_DAEMON 0x02
77 // Wait for the condition variable "CV" to be notified.
78 // Return values:
79 // 0: the condition was notified, or the timeout expired.
80 // _JV_NOT_OWNER: the thread does not own the mutex "MU".
81 // _JV_INTERRUPTED: the thread was interrupted. Its interrupted flag is set.
82 int
83 _Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
84 jlong millis, jint nanos)
86 pthread_t self = pthread_self();
87 if (mu->owner != self)
88 return _JV_NOT_OWNER;
90 struct timespec ts;
91 jlong m, startTime;
93 if (millis > 0 || nanos > 0)
95 startTime = java::lang::System::currentTimeMillis();
96 m = millis + startTime;
97 ts.tv_sec = m / 1000;
98 ts.tv_nsec = ((m % 1000) * 1000000) + nanos;
101 _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
102 java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
104 pthread_mutex_lock (&current->wait_mutex);
106 // Now that we hold the wait mutex, check if this thread has been
107 // interrupted already.
108 if (current_obj->interrupt_flag)
110 pthread_mutex_unlock (&current->wait_mutex);
111 return _JV_INTERRUPTED;
114 // Add this thread to the cv's wait set.
115 current->next = NULL;
117 if (cv->first == NULL)
118 cv->first = current;
119 else
120 for (_Jv_Thread_t *t = cv->first;; t = t->next)
122 if (t->next == NULL)
124 t->next = current;
125 break;
129 // Record the current lock depth, so it can be restored when we re-aquire it.
130 int count = mu->count;
132 // Release the monitor mutex.
133 mu->count = 0;
134 mu->owner = 0;
135 pthread_mutex_unlock (&mu->mutex);
137 int r = 0;
138 bool done_sleeping = false;
140 while (! done_sleeping)
142 if (millis == 0 && nanos == 0)
143 r = pthread_cond_wait (&current->wait_cond, &current->wait_mutex);
144 else
145 r = pthread_cond_timedwait (&current->wait_cond, &current->wait_mutex,
146 &ts);
148 // In older glibc's (prior to 2.1.3), the cond_wait functions may
149 // spuriously wake up on a signal. Catch that here.
150 if (r != EINTR)
151 done_sleeping = true;
154 // Check for an interrupt *before* releasing the wait mutex.
155 jboolean interrupted = current_obj->interrupt_flag;
157 pthread_mutex_unlock (&current->wait_mutex);
159 // Reaquire the monitor mutex, and restore the lock count.
160 pthread_mutex_lock (&mu->mutex);
161 mu->owner = self;
162 mu->count = count;
164 // If we were interrupted, or if a timeout occurred, remove ourself from
165 // the cv wait list now. (If we were notified normally, notify() will have
166 // already taken care of this)
167 if (r == ETIMEDOUT || interrupted)
169 _Jv_Thread_t *prev = NULL;
170 for (_Jv_Thread_t *t = cv->first; t != NULL; t = t->next)
172 if (t == current)
174 if (prev != NULL)
175 prev->next = t->next;
176 else
177 cv->first = t->next;
178 t->next = NULL;
179 break;
181 prev = t;
183 if (interrupted)
184 return _JV_INTERRUPTED;
187 return 0;
191 _Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
193 if (_Jv_PthreadCheckMonitor (mu))
194 return _JV_NOT_OWNER;
196 _Jv_Thread_t *target;
197 _Jv_Thread_t *prev = NULL;
199 for (target = cv->first; target != NULL; target = target->next)
201 pthread_mutex_lock (&target->wait_mutex);
203 if (target->thread_obj->interrupt_flag)
205 // Don't notify a thread that has already been interrupted.
206 pthread_mutex_unlock (&target->wait_mutex);
207 prev = target;
208 continue;
211 pthread_cond_signal (&target->wait_cond);
212 pthread_mutex_unlock (&target->wait_mutex);
214 // Two concurrent notify() calls must not be delivered to the same
215 // thread, so remove the target thread from the cv wait list now.
216 if (prev == NULL)
217 cv->first = target->next;
218 else
219 prev->next = target->next;
221 target->next = NULL;
223 break;
226 return 0;
230 _Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
232 if (_Jv_PthreadCheckMonitor (mu))
233 return _JV_NOT_OWNER;
235 _Jv_Thread_t *target;
236 _Jv_Thread_t *prev = NULL;
238 for (target = cv->first; target != NULL; target = target->next)
240 pthread_mutex_lock (&target->wait_mutex);
241 pthread_cond_signal (&target->wait_cond);
242 pthread_mutex_unlock (&target->wait_mutex);
244 if (prev != NULL)
245 prev->next = NULL;
246 prev = target;
248 if (prev != NULL)
249 prev->next = NULL;
251 cv->first = NULL;
253 return 0;
256 void
257 _Jv_ThreadInterrupt (_Jv_Thread_t *data)
259 pthread_mutex_lock (&data->wait_mutex);
261 // Set the thread's interrupted flag *after* aquiring its wait_mutex. This
262 // ensures that there are no races with the interrupt flag being set after
263 // the waiting thread checks it and before pthread_cond_wait is entered.
264 data->thread_obj->interrupt_flag = true;
266 // Interrupt blocking system calls using a signal.
267 pthread_kill (data->thread, INTR);
269 pthread_cond_signal (&data->wait_cond);
271 pthread_mutex_unlock (&data->wait_mutex);
274 static void
275 handle_intr (int)
277 // Do nothing.
280 void
281 _Jv_InitThreads (void)
283 pthread_key_create (&_Jv_ThreadKey, NULL);
284 pthread_key_create (&_Jv_ThreadDataKey, NULL);
285 pthread_mutex_init (&daemon_mutex, NULL);
286 pthread_cond_init (&daemon_cond, 0);
287 non_daemon_count = 0;
289 // Arrange for the interrupt signal to interrupt system calls.
290 struct sigaction act;
291 act.sa_handler = handle_intr;
292 sigemptyset (&act.sa_mask);
293 act.sa_flags = 0;
294 sigaction (INTR, &act, NULL);
297 _Jv_Thread_t *
298 _Jv_ThreadInitData (java::lang::Thread *obj)
300 _Jv_Thread_t *data = (_Jv_Thread_t *) _Jv_Malloc (sizeof (_Jv_Thread_t));
301 data->flags = 0;
302 data->thread_obj = obj;
304 pthread_mutex_init (&data->wait_mutex, NULL);
305 pthread_cond_init (&data->wait_cond, NULL);
307 return data;
310 void
311 _Jv_ThreadDestroyData (_Jv_Thread_t *data)
313 pthread_mutex_destroy (&data->wait_mutex);
314 pthread_cond_destroy (&data->wait_cond);
315 _Jv_Free ((void *)data);
318 void
319 _Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
321 if (data->flags & FLAG_START)
323 struct sched_param param;
325 param.sched_priority = prio;
326 pthread_setschedparam (data->thread, SCHED_RR, &param);
330 void
331 _Jv_ThreadRegister (_Jv_Thread_t *data)
333 pthread_setspecific (_Jv_ThreadKey, data->thread_obj);
334 pthread_setspecific (_Jv_ThreadDataKey, data);
336 // glibc 2.1.3 doesn't set the value of `thread' until after start_routine
337 // is called. Since it may need to be accessed from the new thread, work
338 // around the potential race here by explicitly setting it again.
339 data->thread = pthread_self ();
341 # ifdef SLOW_PTHREAD_SELF
342 // Clear all self cache slots that might be needed by this thread.
343 int dummy;
344 int low_index = SC_INDEX(&dummy) + SC_CLEAR_MIN;
345 int high_index = SC_INDEX(&dummy) + SC_CLEAR_MAX;
346 for (int i = low_index; i <= high_index; ++i)
348 int current_index = i;
349 if (current_index < 0)
350 current_index += SELF_CACHE_SIZE;
351 if (current_index >= SELF_CACHE_SIZE)
352 current_index -= SELF_CACHE_SIZE;
353 _Jv_self_cache[current_index].high_sp_bits = BAD_HIGH_SP_VALUE;
355 # endif
358 void
359 _Jv_ThreadUnRegister ()
361 pthread_setspecific (_Jv_ThreadKey, NULL);
362 pthread_setspecific (_Jv_ThreadDataKey, NULL);
365 // This function is called when a thread is started. We don't arrange
366 // to call the `run' method directly, because this function must
367 // return a value.
368 static void *
369 really_start (void *x)
371 struct starter *info = (struct starter *) x;
373 _Jv_ThreadRegister (info->data);
375 info->method (info->data->thread_obj);
377 if (! (info->data->flags & FLAG_DAEMON))
379 pthread_mutex_lock (&daemon_mutex);
380 --non_daemon_count;
381 if (! non_daemon_count)
382 pthread_cond_signal (&daemon_cond);
383 pthread_mutex_unlock (&daemon_mutex);
386 return NULL;
389 void
390 _Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
391 _Jv_ThreadStartFunc *meth)
393 struct sched_param param;
394 pthread_attr_t attr;
395 struct starter *info;
397 if (data->flags & FLAG_START)
398 return;
399 data->flags |= FLAG_START;
401 param.sched_priority = thread->getPriority();
403 pthread_attr_init (&attr);
404 pthread_attr_setschedparam (&attr, &param);
405 pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
407 info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
408 info->method = meth;
409 info->data = data;
411 if (! thread->isDaemon())
413 pthread_mutex_lock (&daemon_mutex);
414 ++non_daemon_count;
415 pthread_mutex_unlock (&daemon_mutex);
417 else
418 data->flags |= FLAG_DAEMON;
419 int r = pthread_create (&data->thread, &attr, really_start, (void *) info);
421 pthread_attr_destroy (&attr);
423 if (r)
425 const char* msg = "Cannot create additional threads";
426 throw new java::lang::OutOfMemoryError (JvNewStringUTF (msg));
430 void
431 _Jv_ThreadWait (void)
433 pthread_mutex_lock (&daemon_mutex);
434 if (non_daemon_count)
435 pthread_cond_wait (&daemon_cond, &daemon_mutex);
436 pthread_mutex_unlock (&daemon_mutex);
439 #if defined(SLOW_PTHREAD_SELF)
441 #include "sysdep/locks.h"
443 // Support for pthread_self() lookup cache.
444 volatile self_cache_entry _Jv_self_cache[SELF_CACHE_SIZE];
446 _Jv_ThreadId_t
447 _Jv_ThreadSelf_out_of_line(volatile self_cache_entry *sce, size_t high_sp_bits)
449 pthread_t self = pthread_self();
450 sce -> high_sp_bits = high_sp_bits;
451 write_barrier();
452 sce -> self = self;
453 return self;
456 #endif /* SLOW_PTHREAD_SELF */