OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libjava/] [posix-threads.cc] - Blame information for rev 757

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 753 jeremybenn
// posix-threads.cc - interface between libjava and POSIX threads.
2
 
3
/* Copyright (C) 1998, 1999, 2000, 2001, 2004, 2006  Free Software Foundation
4
 
5
   This file is part of libgcj.
6
 
7
This software is copyrighted work licensed under the terms of the
8
Libgcj License.  Please consult the file "LIBGCJ_LICENSE" for
9
details.  */
10
 
11
// TO DO:
12
// * Document signal handling limitations
13
 
14
#include <config.h>
15
 
16
#include "posix.h"
17
#include "posix-threads.h"
18
 
19
// If we're using the Boehm GC, then we need to override some of the
20
// thread primitives.  This is fairly gross.
21
#ifdef HAVE_BOEHM_GC
22
#include <gc.h>
23
#endif /* HAVE_BOEHM_GC */
24
 
25
#include <stdlib.h>
26
#include <time.h>
27
#include <signal.h>
28
#include <errno.h>
29
#include <limits.h>
30
#ifdef HAVE_UNISTD_H
31
#include <unistd.h>     // To test for _POSIX_THREAD_PRIORITY_SCHEDULING
32
#endif
33
 
34
#include <gcj/cni.h>
35
#include <jvm.h>
36
#include <java/lang/Thread.h>
37
#include <java/lang/System.h>
38
#include <java/lang/Long.h>
39
#include <java/lang/OutOfMemoryError.h>
40
#include <java/lang/InternalError.h>
41
 
42
// This is used to implement thread startup.
43
struct starter
44
{
45
  _Jv_ThreadStartFunc *method;
46
  _Jv_Thread_t *data;
47
};
48
 
49
// This is the key used to map from the POSIX thread value back to the
50
// Java object representing the thread.  The key is global to all
51
// threads, so it is ok to make it a global here.
52
pthread_key_t _Jv_ThreadKey;
53
 
54
// This is the key used to map from the POSIX thread value back to the
55
// _Jv_Thread_t* representing the thread.
56
pthread_key_t _Jv_ThreadDataKey;
57
 
58
// We keep a count of all non-daemon threads which are running.  When
59
// this reaches zero, _Jv_ThreadWait returns.
60
static pthread_mutex_t daemon_mutex;
61
static pthread_cond_t daemon_cond;
62
static int non_daemon_count;
63
 
64
// The signal to use when interrupting a thread.
65
#if defined(LINUX_THREADS) || defined(FREEBSD_THREADS)
66
  // LinuxThreads (prior to glibc 2.1) usurps both SIGUSR1 and SIGUSR2.
67
  // GC on FreeBSD uses both SIGUSR1 and SIGUSR2.
68
#  define INTR SIGHUP
69
#else /* LINUX_THREADS */
70
#  define INTR SIGUSR2
71
#endif /* LINUX_THREADS */
72
 
73
//
74
// These are the flags that can appear in _Jv_Thread_t.
75
//
76
 
77
// Thread started.
78
#define FLAG_START   0x01
79
// Thread is daemon.
80
#define FLAG_DAEMON  0x02
81
 
82
 
83
 
84
int
85
_Jv_MutexLock (_Jv_Mutex_t *mu)
86
{
87
  pthread_t self = pthread_self ();
88
  if (mu->owner == self)
89
    {
90
      mu->count++;
91
    }
92
  else
93
    {
94
      JvSetThreadState holder (_Jv_ThreadCurrent(), JV_BLOCKED);
95
 
96
#     ifdef LOCK_DEBUG
97
        int result = pthread_mutex_lock (&mu->mutex);
98
        if (0 != result)
99
          {
100
            fprintf(stderr, "Pthread_mutex_lock returned %d\n", result);
101
            for (;;) {}
102
          }
103
#     else
104
        pthread_mutex_lock (&mu->mutex);
105
#     endif
106
      mu->count = 1;
107
      mu->owner = self;
108
    }
109
  return 0;
110
}
111
 
112
// Wait for the condition variable "CV" to be notified. 
113
// Return values:
114
// 0: the condition was notified, or the timeout expired.
115
// _JV_NOT_OWNER: the thread does not own the mutex "MU".   
116
// _JV_INTERRUPTED: the thread was interrupted. Its interrupted flag is set.   
117
int
118
_Jv_CondWait (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu,
119
              jlong millis, jint nanos)
120
{
121
  pthread_t self = pthread_self();
122
  if (mu->owner != self)
123
    return _JV_NOT_OWNER;
124
 
125
  struct timespec ts;
126
 
127
  JvThreadState new_state = JV_WAITING;
128
  if (millis > 0 || nanos > 0)
129
    {
130
      // Calculate the abstime corresponding to the timeout.
131
      unsigned long long seconds;
132
      unsigned long usec;
133
 
134
      // For better accuracy, should use pthread_condattr_setclock
135
      // and clock_gettime.
136
#ifdef HAVE_GETTIMEOFDAY
137
      timeval tv;
138
      gettimeofday (&tv, NULL);
139
      usec = tv.tv_usec;
140
      seconds = tv.tv_sec;
141
#else
142
      unsigned long long startTime = java::lang::System::currentTimeMillis();
143
      seconds = startTime / 1000;
144
      /* Assume we're about half-way through this millisecond.  */
145
      usec = (startTime % 1000) * 1000 + 500;
146
#endif
147
      /* These next two statements cannot overflow.  */
148
      usec += nanos / 1000;
149
      usec += (millis % 1000) * 1000;
150
      /* These two statements could overflow only if tv.tv_sec was
151
         insanely large.  */
152
      seconds += millis / 1000;
153
      seconds += usec / 1000000;
154
 
155
      ts.tv_sec = seconds;
156
      if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
157
        {
158
          // We treat a timeout that won't fit into a struct timespec
159
          // as a wait forever.
160
          millis = nanos = 0;
161
        }
162
      else
163
        /* This next statement also cannot overflow.  */
164
        ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
165
    }
166
 
167
  _Jv_Thread_t *current = _Jv_ThreadCurrentData ();
168
  java::lang::Thread *current_obj = _Jv_ThreadCurrent ();
169
 
170
  pthread_mutex_lock (&current->wait_mutex);
171
 
172
  // Now that we hold the wait mutex, check if this thread has been 
173
  // interrupted already.
174
  if (current_obj->interrupt_flag)
175
    {
176
      pthread_mutex_unlock (&current->wait_mutex);
177
      return _JV_INTERRUPTED;
178
    }
179
 
180
  // Set the thread's state.
181
  JvSetThreadState holder (current_obj, new_state);
182
 
183
  // Add this thread to the cv's wait set.
184
  current->next = NULL;
185
 
186
  if (cv->first == NULL)
187
    cv->first = current;
188
  else
189
    for (_Jv_Thread_t *t = cv->first;; t = t->next)
190
      {
191
        if (t->next == NULL)
192
          {
193
            t->next = current;
194
            break;
195
          }
196
      }
197
 
198
  // Record the current lock depth, so it can be restored when we re-aquire it.
199
  int count = mu->count;
200
 
201
  // Release the monitor mutex.
202
  mu->count = 0;
203
  mu->owner = 0;
204
  pthread_mutex_unlock (&mu->mutex);
205
 
206
  int r = 0;
207
  bool done_sleeping = false;
208
 
209
  while (! done_sleeping)
210
    {
211
      if (millis == 0 && nanos == 0)
212
        r = pthread_cond_wait (&current->wait_cond, &current->wait_mutex);
213
      else
214
        r = pthread_cond_timedwait (&current->wait_cond, &current->wait_mutex,
215
                                    &ts);
216
 
217
      // In older glibc's (prior to 2.1.3), the cond_wait functions may 
218
      // spuriously wake up on a signal. Catch that here.
219
      if (r != EINTR)
220
        done_sleeping = true;
221
    }
222
 
223
  // Check for an interrupt *before* releasing the wait mutex.
224
  jboolean interrupted = current_obj->interrupt_flag;
225
 
226
  pthread_mutex_unlock (&current->wait_mutex);
227
 
228
  //  Reaquire the monitor mutex, and restore the lock count.
229
  pthread_mutex_lock (&mu->mutex);
230
  mu->owner = self;
231
  mu->count = count;
232
 
233
  // If we were interrupted, or if a timeout occurred, remove ourself from
234
  // the cv wait list now. (If we were notified normally, notify() will have
235
  // already taken care of this)
236
  if (r == ETIMEDOUT || interrupted)
237
    {
238
      _Jv_Thread_t *prev = NULL;
239
      for (_Jv_Thread_t *t = cv->first; t != NULL; t = t->next)
240
        {
241
          if (t == current)
242
            {
243
              if (prev != NULL)
244
                prev->next = t->next;
245
              else
246
                cv->first = t->next;
247
              t->next = NULL;
248
              break;
249
            }
250
          prev = t;
251
        }
252
      if (interrupted)
253
        return _JV_INTERRUPTED;
254
    }
255
 
256
  return 0;
257
}
258
 
259
int
260
_Jv_CondNotify (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
261
{
262
  if (_Jv_MutexCheckMonitor (mu))
263
    return _JV_NOT_OWNER;
264
 
265
  _Jv_Thread_t *target;
266
  _Jv_Thread_t *prev = NULL;
267
 
268
  for (target = cv->first; target != NULL; target = target->next)
269
    {
270
      pthread_mutex_lock (&target->wait_mutex);
271
 
272
      if (target->thread_obj->interrupt_flag)
273
        {
274
          // Don't notify a thread that has already been interrupted.
275
          pthread_mutex_unlock (&target->wait_mutex);
276
          prev = target;
277
          continue;
278
        }
279
 
280
      pthread_cond_signal (&target->wait_cond);
281
      pthread_mutex_unlock (&target->wait_mutex);
282
 
283
      // Two concurrent notify() calls must not be delivered to the same 
284
      // thread, so remove the target thread from the cv wait list now.
285
      if (prev == NULL)
286
        cv->first = target->next;
287
      else
288
        prev->next = target->next;
289
 
290
      target->next = NULL;
291
 
292
      break;
293
    }
294
 
295
  return 0;
296
}
297
 
298
int
299
_Jv_CondNotifyAll (_Jv_ConditionVariable_t *cv, _Jv_Mutex_t *mu)
300
{
301
  if (_Jv_MutexCheckMonitor (mu))
302
    return _JV_NOT_OWNER;
303
 
304
  _Jv_Thread_t *target;
305
  _Jv_Thread_t *prev = NULL;
306
 
307
  for (target = cv->first; target != NULL; target = target->next)
308
    {
309
      pthread_mutex_lock (&target->wait_mutex);
310
      pthread_cond_signal (&target->wait_cond);
311
      pthread_mutex_unlock (&target->wait_mutex);
312
 
313
      if (prev != NULL)
314
        prev->next = NULL;
315
      prev = target;
316
    }
317
  if (prev != NULL)
318
    prev->next = NULL;
319
 
320
  cv->first = NULL;
321
 
322
  return 0;
323
}
324
 
325
void
326
_Jv_ThreadInterrupt (_Jv_Thread_t *data)
327
{
328
  pthread_mutex_lock (&data->wait_mutex);
329
 
330
  // Set the thread's interrupted flag *after* aquiring its wait_mutex. This
331
  // ensures that there are no races with the interrupt flag being set after 
332
  // the waiting thread checks it and before pthread_cond_wait is entered.
333
  data->thread_obj->interrupt_flag = true;
334
 
335
  // Interrupt blocking system calls using a signal.
336
  pthread_kill (data->thread, INTR);
337
 
338
  pthread_cond_signal (&data->wait_cond);
339
 
340
  pthread_mutex_unlock (&data->wait_mutex);
341
}
342
 
343
/**
344
 * Releases the block on a thread created by _Jv_ThreadPark().  This
345
 * method can also be used to terminate a blockage caused by a prior
346
 * call to park.  This operation is unsafe, as the thread must be
347
 * guaranteed to be live.
348
 *
349
 * @param thread the thread to unblock.
350
 */
351
void
352
ParkHelper::unpark ()
353
{
354
  using namespace ::java::lang;
355
  volatile obj_addr_t *ptr = &permit;
356
 
357
  /* If this thread is in state RUNNING, give it a permit and return
358
     immediately.  */
359
  if (compare_and_swap
360
      (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PERMIT))
361
    return;
362
 
363
  /* If this thread is parked, put it into state RUNNING and send it a
364
     signal.  */
365
  if (compare_and_swap
366
      (ptr, Thread::THREAD_PARK_PARKED, Thread::THREAD_PARK_RUNNING))
367
    {
368
      int result;
369
      pthread_mutex_lock (&mutex);
370
      result = pthread_cond_signal (&cond);
371
      pthread_mutex_unlock (&mutex);
372
      JvAssert (result == 0);
373
    }
374
}
375
 
376
/**
377
 * Sets our state to dead.
378
 */
379
void
380
ParkHelper::deactivate ()
381
{
382
  permit = ::java::lang::Thread::THREAD_PARK_DEAD;
383
}
384
 
385
void
386
ParkHelper::init ()
387
{
388
  pthread_mutex_init (&mutex, NULL);
389
  pthread_cond_init (&cond, NULL);
390
  permit = ::java::lang::Thread::THREAD_PARK_RUNNING;
391
}
392
 
393
/**
394
 * Blocks the thread until a matching _Jv_ThreadUnpark() occurs, the
395
 * thread is interrupted or the optional timeout expires.  If an
396
 * unpark call has already occurred, this also counts.  A timeout
397
 * value of zero is defined as no timeout.  When isAbsolute is true,
398
 * the timeout is in milliseconds relative to the epoch.  Otherwise,
399
 * the value is the number of nanoseconds which must occur before
400
 * timeout.  This call may also return spuriously (i.e.  for no
401
 * apparent reason).
402
 *
403
 * @param isAbsolute true if the timeout is specified in milliseconds from
404
 *                   the epoch.
405
 * @param time either the number of nanoseconds to wait, or a time in
406
 *             milliseconds from the epoch to wait for.
407
 */
408
void
409
ParkHelper::park (jboolean isAbsolute, jlong time)
410
{
411
  using namespace ::java::lang;
412
  volatile obj_addr_t *ptr = &permit;
413
 
414
  /* If we have a permit, return immediately.  */
415
  if (compare_and_swap
416
      (ptr, Thread::THREAD_PARK_PERMIT, Thread::THREAD_PARK_RUNNING))
417
    return;
418
 
419
  struct timespec ts;
420
 
421
  if (time)
422
    {
423
      unsigned long long seconds;
424
      unsigned long usec;
425
 
426
      if (isAbsolute)
427
        {
428
          ts.tv_sec = time / 1000;
429
          ts.tv_nsec = (time % 1000) * 1000 * 1000;
430
        }
431
      else
432
        {
433
          // Calculate the abstime corresponding to the timeout.
434
          jlong nanos = time;
435
          jlong millis = 0;
436
 
437
          // For better accuracy, should use pthread_condattr_setclock
438
          // and clock_gettime.
439
#ifdef HAVE_GETTIMEOFDAY
440
          timeval tv;
441
          gettimeofday (&tv, NULL);
442
          usec = tv.tv_usec;
443
          seconds = tv.tv_sec;
444
#else
445
          unsigned long long startTime
446
            = java::lang::System::currentTimeMillis();
447
          seconds = startTime / 1000;
448
          /* Assume we're about half-way through this millisecond.  */
449
          usec = (startTime % 1000) * 1000 + 500;
450
#endif
451
          /* These next two statements cannot overflow.  */
452
          usec += nanos / 1000;
453
          usec += (millis % 1000) * 1000;
454
          /* These two statements could overflow only if tv.tv_sec was
455
             insanely large.  */
456
          seconds += millis / 1000;
457
          seconds += usec / 1000000;
458
 
459
          ts.tv_sec = seconds;
460
          if (ts.tv_sec < 0 || (unsigned long long)ts.tv_sec != seconds)
461
            {
462
              // We treat a timeout that won't fit into a struct timespec
463
              // as a wait forever.
464
              millis = nanos = 0;
465
            }
466
          else
467
            /* This next statement also cannot overflow.  */
468
            ts.tv_nsec = (usec % 1000000) * 1000 + (nanos % 1000);
469
        }
470
    }
471
 
472
  pthread_mutex_lock (&mutex);
473
  if (compare_and_swap
474
      (ptr, Thread::THREAD_PARK_RUNNING, Thread::THREAD_PARK_PARKED))
475
    {
476
      int result = 0;
477
 
478
      if (! time)
479
        result = pthread_cond_wait (&cond, &mutex);
480
      else
481
        result = pthread_cond_timedwait (&cond, &mutex, &ts);
482
 
483
      JvAssert (result == 0 || result == ETIMEDOUT);
484
 
485
      /* If we were unparked by some other thread, this will already
486
         be in state THREAD_PARK_RUNNING.  If we timed out or were
487
         interrupted, we have to do it ourself.  */
488
      permit = Thread::THREAD_PARK_RUNNING;
489
    }
490
  pthread_mutex_unlock (&mutex);
491
}
492
 
493
static void
494
handle_intr (int)
495
{
496
  // Do nothing.
497
}
498
 
499
void
500
_Jv_BlockSigchld()
501
{
502
  sigset_t mask;
503
  sigemptyset (&mask);
504
  sigaddset (&mask, SIGCHLD);
505
  int c = pthread_sigmask (SIG_BLOCK, &mask, NULL);
506
  if (c != 0)
507
    JvFail (strerror (c));
508
}
509
 
510
void
511
_Jv_UnBlockSigchld()
512
{
513
  sigset_t mask;
514
  sigemptyset (&mask);
515
  sigaddset (&mask, SIGCHLD);
516
  int c = pthread_sigmask (SIG_UNBLOCK, &mask, NULL);
517
  if (c != 0)
518
    JvFail (strerror (c));
519
}
520
 
521
void
522
_Jv_InitThreads (void)
523
{
524
  pthread_key_create (&_Jv_ThreadKey, NULL);
525
  pthread_key_create (&_Jv_ThreadDataKey, NULL);
526
  pthread_mutex_init (&daemon_mutex, NULL);
527
  pthread_cond_init (&daemon_cond, 0);
528
  non_daemon_count = 0;
529
 
530
  // Arrange for the interrupt signal to interrupt system calls.
531
  struct sigaction act;
532
  act.sa_handler = handle_intr;
533
  sigemptyset (&act.sa_mask);
534
  act.sa_flags = 0;
535
  sigaction (INTR, &act, NULL);
536
 
537
  // Block SIGCHLD here to ensure that any non-Java threads inherit the new 
538
  // signal mask.
539
  _Jv_BlockSigchld();
540
 
541
  // Check/set the thread stack size.
542
  size_t min_ss = 32 * 1024;
543
 
544
  if (sizeof (void *) == 8)
545
    // Bigger default on 64-bit systems.
546
    min_ss *= 2;
547
 
548
#ifdef PTHREAD_STACK_MIN
549
  if (min_ss < PTHREAD_STACK_MIN)
550
    min_ss = PTHREAD_STACK_MIN;
551
#endif
552
 
553
  if (gcj::stack_size > 0 && gcj::stack_size < min_ss)
554
    gcj::stack_size = min_ss;
555
}
556
 
557
_Jv_Thread_t *
558
_Jv_ThreadInitData (java::lang::Thread *obj)
559
{
560
  _Jv_Thread_t *data = (_Jv_Thread_t *) _Jv_Malloc (sizeof (_Jv_Thread_t));
561
  data->flags = 0;
562
  data->thread_obj = obj;
563
 
564
  pthread_mutex_init (&data->wait_mutex, NULL);
565
  pthread_cond_init (&data->wait_cond, NULL);
566
 
567
  return data;
568
}
569
 
570
void
571
_Jv_ThreadDestroyData (_Jv_Thread_t *data)
572
{
573
  pthread_mutex_destroy (&data->wait_mutex);
574
  pthread_cond_destroy (&data->wait_cond);
575
  _Jv_Free ((void *)data);
576
}
577
 
578
void
579
_Jv_ThreadSetPriority (_Jv_Thread_t *data, jint prio)
580
{
581
#ifdef _POSIX_THREAD_PRIORITY_SCHEDULING
582
  if (data->flags & FLAG_START)
583
    {
584
      struct sched_param param;
585
 
586
      param.sched_priority = prio;
587
      pthread_setschedparam (data->thread, SCHED_OTHER, &param);
588
    }
589
#endif
590
}
591
 
592
void
593
_Jv_ThreadRegister (_Jv_Thread_t *data)
594
{
595
  pthread_setspecific (_Jv_ThreadKey, data->thread_obj);
596
  pthread_setspecific (_Jv_ThreadDataKey, data);
597
 
598
  // glibc 2.1.3 doesn't set the value of `thread' until after start_routine
599
  // is called. Since it may need to be accessed from the new thread, work 
600
  // around the potential race here by explicitly setting it again.
601
  data->thread = pthread_self ();
602
 
603
# ifdef SLOW_PTHREAD_SELF
604
    // Clear all self cache slots that might be needed by this thread.
605
    int dummy;
606
    int low_index = SC_INDEX(&dummy) + SC_CLEAR_MIN;
607
    int high_index = SC_INDEX(&dummy) + SC_CLEAR_MAX;
608
    for (int i = low_index; i <= high_index; ++i)
609
      {
610
        int current_index = i;
611
        if (current_index < 0)
612
          current_index += SELF_CACHE_SIZE;
613
        if (current_index >= SELF_CACHE_SIZE)
614
          current_index -= SELF_CACHE_SIZE;
615
        _Jv_self_cache[current_index].high_sp_bits = BAD_HIGH_SP_VALUE;
616
      }
617
# endif
618
  // Block SIGCHLD which is used in natPosixProcess.cc.
619
  _Jv_BlockSigchld();
620
}
621
 
622
void
623
_Jv_ThreadUnRegister ()
624
{
625
  pthread_setspecific (_Jv_ThreadKey, NULL);
626
  pthread_setspecific (_Jv_ThreadDataKey, NULL);
627
}
628
 
629
// This function is called when a thread is started.  We don't arrange
630
// to call the `run' method directly, because this function must
631
// return a value.
632
static void *
633
really_start (void *x)
634
{
635
  struct starter *info = (struct starter *) x;
636
 
637
  _Jv_ThreadRegister (info->data);
638
 
639
  info->method (info->data->thread_obj);
640
 
641
  if (! (info->data->flags & FLAG_DAEMON))
642
    {
643
      pthread_mutex_lock (&daemon_mutex);
644
      --non_daemon_count;
645
      if (! non_daemon_count)
646
        pthread_cond_signal (&daemon_cond);
647
      pthread_mutex_unlock (&daemon_mutex);
648
    }
649
 
650
  return NULL;
651
}
652
 
653
void
654
_Jv_ThreadStart (java::lang::Thread *thread, _Jv_Thread_t *data,
655
                 _Jv_ThreadStartFunc *meth)
656
{
657
  struct sched_param param;
658
  pthread_attr_t attr;
659
  struct starter *info;
660
 
661
  if (data->flags & FLAG_START)
662
    return;
663
  data->flags |= FLAG_START;
664
 
665
  // Block SIGCHLD which is used in natPosixProcess.cc.
666
  // The current mask is inherited by the child thread.
667
  _Jv_BlockSigchld();
668
 
669
  param.sched_priority = thread->getPriority();
670
 
671
  pthread_attr_init (&attr);
672
  pthread_attr_setschedparam (&attr, &param);
673
  pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED);
674
 
675
  // Set stack size if -Xss option was given.
676
  if (gcj::stack_size > 0)
677
    {
678
      int e = pthread_attr_setstacksize (&attr, gcj::stack_size);
679
      if (e != 0)
680
        JvFail (strerror (e));
681
    }
682
 
683
  info = (struct starter *) _Jv_AllocBytes (sizeof (struct starter));
684
  info->method = meth;
685
  info->data = data;
686
 
687
  if (! thread->isDaemon())
688
    {
689
      pthread_mutex_lock (&daemon_mutex);
690
      ++non_daemon_count;
691
      pthread_mutex_unlock (&daemon_mutex);
692
    }
693
  else
694
    data->flags |= FLAG_DAEMON;
695
  int r = pthread_create (&data->thread, &attr, really_start, (void *) info);
696
 
697
  pthread_attr_destroy (&attr);
698
 
699
  if (r)
700
    {
701
      const char* msg = "Cannot create additional threads";
702
      throw new java::lang::OutOfMemoryError (JvNewStringUTF (msg));
703
    }
704
}
705
 
706
void
707
_Jv_ThreadWait (void)
708
{
709
  pthread_mutex_lock (&daemon_mutex);
710
  if (non_daemon_count)
711
    pthread_cond_wait (&daemon_cond, &daemon_mutex);
712
  pthread_mutex_unlock (&daemon_mutex);
713
}
714
 
715
#if defined(SLOW_PTHREAD_SELF)
716
 
717
#include "sysdep/locks.h"
718
 
719
// Support for pthread_self() lookup cache.
720
volatile self_cache_entry _Jv_self_cache[SELF_CACHE_SIZE];
721
 
722
_Jv_ThreadId_t
723
_Jv_ThreadSelf_out_of_line(volatile self_cache_entry *sce, size_t high_sp_bits)
724
{
725
  pthread_t self = pthread_self();
726
  sce -> high_sp_bits = high_sp_bits;
727
  write_barrier();
728
  sce -> self = self;
729
  return self;
730
}
731
 
732
#endif /* SLOW_PTHREAD_SELF */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.