Rainer Orth <r...@cebitec.uni-bielefeld.de> writes:
> Rainer Orth <r...@cebitec.uni-bielefeld.de> writes:
>
>> This broke bootstrap on Linux/x86_64 (CentOS 5.5), which lacks
>> O_CLOEXEC.
>
> ... and also Solaris 8 and 9 bootstrap which lack sem_timedwait:
>
> /vol/gcc/src/hg/trunk/local/libgo/runtime/thread-sema.c: In function
> 'runtime_semasleep':
> /vol/gcc/src/hg/trunk/local/libgo/runtime/thread-sema.c:42:7: error: implicit
> declaration of function 'sem_timedwait'
> [-Werror=implicit-function-declaration]
This one was somewhat trickier, but I think this patch will do the job.
This uses pthread_cond_timedwait instead of sem_timedwait (I hope that
Solaris 8 and 9 have pthread_cond_timedwait). Bootstrapped and ran Go
testsuite on x86_64-unknown-linux-gnu. Committed to mainline.
Ian
diff -r cf5fa6d457da libgo/configure.ac
--- a/libgo/configure.ac Tue Nov 29 11:38:05 2011 -0800
+++ b/libgo/configure.ac Tue Nov 29 13:54:16 2011 -0800
@@ -456,6 +456,14 @@
AM_CONDITIONAL(HAVE_STRERROR_R, test "$ac_cv_func_strerror_r" = yes)
AM_CONDITIONAL(HAVE_WAIT4, test "$ac_cv_func_wait4" = yes)
+CFLAGS_hold="$CFLAGS"
+CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
+LIBS_hold="$LIBS"
+LIBS="$LIBS $PTHREAD_LIBS"
+AC_CHECK_FUNCS(sem_timedwait)
+CFLAGS="$CFLAGS_hold"
+LIBS="$LIBS_hold"
+
AC_CACHE_CHECK([for __sync_bool_compare_and_swap_4],
[libgo_cv_func___sync_bool_compare_and_swap_4],
[AC_LINK_IFELSE([
diff -r cf5fa6d457da libgo/runtime/lock_sema.c
--- a/libgo/runtime/lock_sema.c Tue Nov 29 11:38:05 2011 -0800
+++ b/libgo/runtime/lock_sema.c Tue Nov 29 13:54:16 2011 -0800
@@ -32,9 +32,11 @@
void
runtime_lock(Lock *l)
{
+ M *m;
uintptr v;
uint32 i, spin;
+ m = runtime_m();
if(m->locks++ < 0)
runtime_throw("runtime_lock: lock count");
@@ -91,7 +93,7 @@
uintptr v;
M *mp;
- if(--m->locks < 0)
+ if(--runtime_m()->locks < 0)
runtime_throw("runtime_unlock: lock count");
for(;;) {
@@ -144,6 +146,9 @@
void
runtime_notesleep(Note *n)
{
+ M *m;
+
+ m = runtime_m();
if(m->waitsema == 0)
m->waitsema = runtime_semacreate();
if(!runtime_casp(&n->waitm, nil, m)) { // must be LOCKED (got wakeup)
@@ -158,6 +163,7 @@
void
runtime_notetsleep(Note *n, int64 ns)
{
+ M *m;
M *mp;
int64 deadline, now;
@@ -166,6 +172,7 @@
return;
}
+ m = runtime_m();
if(m->waitsema == 0)
m->waitsema = runtime_semacreate();
diff -r cf5fa6d457da libgo/runtime/thread-sema.c
--- a/libgo/runtime/thread-sema.c Tue Nov 29 11:38:05 2011 -0800
+++ b/libgo/runtime/thread-sema.c Tue Nov 29 13:54:16 2011 -0800
@@ -2,6 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
+#include "config.h"
#include "runtime.h"
#include <errno.h>
@@ -9,19 +10,43 @@
#include <time.h>
#include <semaphore.h>
+/* If we don't have sem_timedwait, use pthread_cond_timedwait instead.
+ We don't always use condition variables because on some systems
+ pthread_mutex_lock and pthread_mutex_unlock must be called by the
+ same thread. That is never true of semaphores. */
+
+struct go_sem
+{
+ sem_t sem;
+
+#ifndef HAVE_SEM_TIMEDWAIT
+ int timedwait;
+ pthread_mutex_t mutex;
+ pthread_cond_t cond;
+#endif
+};
+
/* Create a semaphore. */
uintptr
runtime_semacreate(void)
{
- sem_t *p;
+ struct go_sem *p;
/* Call malloc rather than runtime_malloc. This will allocate space
on the C heap. We can't call runtime_malloc here because it
could cause a deadlock. */
- p = malloc (sizeof (sem_t));
- if (sem_init (p, 0, 0) != 0)
+ p = malloc (sizeof (struct go_sem));
+ if (sem_init (&p->sem, 0, 0) != 0)
runtime_throw ("sem_init");
+
+#ifndef HAVE_SEM_TIMEDWAIT
+ if (pthread_mutex_init (&p->mutex, NULL) != 0)
+ runtime_throw ("pthread_mutex_init");
+ if (pthread_cond_init (&p->cond, NULL) != 0)
+ runtime_throw ("pthread_cond_init");
+#endif
+
return (uintptr) p;
}
@@ -30,26 +55,56 @@
int32
runtime_semasleep (int64 ns)
{
+ M *m;
+ struct go_sem *sem;
int r;
+ m = runtime_m ();
+ sem = (struct go_sem *) m->waitsema;
if (ns >= 0)
{
+ int64 abs;
struct timespec ts;
+ int err;
- ns += runtime_nanotime ();
- ts.tv_sec = ns / 1000000000LL;
- ts.tv_nsec = ns % 1000000000LL;
- r = sem_timedwait ((sem_t *) m->waitsema, &ts);
+ abs = ns + runtime_nanotime ();
+ ts.tv_sec = abs / 1000000000LL;
+ ts.tv_nsec = abs % 1000000000LL;
+
+ err = 0;
+
+#ifdef HAVE_SEM_TIMEDWAIT
+ r = sem_timedwait (&sem->sem, &ts);
if (r != 0)
+ err = errno;
+#else
+ if (pthread_mutex_lock (&sem->mutex) != 0)
+ runtime_throw ("pthread_mutex_lock");
+
+ while ((r = sem_trywait (&sem->sem)) != 0)
{
- if (errno == ETIMEDOUT || errno == EINTR)
+ r = pthread_cond_timedwait (&sem->cond, &sem->mutex, &ts);
+ if (r != 0)
+ {
+ err = r;
+ break;
+ }
+ }
+
+ if (pthread_mutex_unlock (&sem->mutex) != 0)
+ runtime_throw ("pthread_mutex_unlock");
+#endif
+
+ if (err != 0)
+ {
+ if (err == ETIMEDOUT || err == EAGAIN || err == EINTR)
return -1;
runtime_throw ("sema_timedwait");
}
return 0;
}
- while (sem_wait ((sem_t *) m->waitsema) != 0)
+ while (sem_wait (&sem->sem) != 0)
{
if (errno == EINTR)
continue;
@@ -64,8 +119,20 @@
void
runtime_semawakeup (M *mp)
{
- if (sem_post ((sem_t *) mp->waitsema) != 0)
+ struct go_sem *sem;
+
+ sem = (struct go_sem *) mp->waitsema;
+ if (sem_post (&sem->sem) != 0)
runtime_throw ("sem_post");
+
+#ifndef HAVE_SEM_TIMEDWAIT
+ if (pthread_mutex_lock (&sem->mutex) != 0)
+ runtime_throw ("pthread_mutex_lock");
+ if (pthread_cond_broadcast (&sem->cond) != 0)
+ runtime_throw ("pthread_cond_broadcast");
+ if (pthread_mutex_unlock (&sem->mutex) != 0)
+ runtime_throw ("pthread_mutex_unlock");
+#endif
}
void
