* coop.c (coop_mutex_init, coop_mutex_lock, coop_mutex_unlock,

coop_condition_variable_init, coop_condition_variable_wait,
coop_condition_variable_signal): Changed return type from `void'
to `int'.  This is to adhere closer to the pthreads interface.
This, in turn, is part of an attempt to provide C versions of the
mutex and condition variable primitives which can be part of a
frontend to COOP or pthreads.

* coop.c (coop_mutex_destroy, coop_condition_variable_wait_mutex,
coop_condition_variable_destroy): New functions.

* coop-threads.c (scm_wait_condition_variable): Use
coop_condition_variable_wait_mutex.

* coop-threads.h, coop-defs.h (coop_q_t, coop_m, coop_c):
Definitions moved to coop-defs.h.

* coop-defs.h (scm_mutex_init, scm_mutex_lock, scm_mutex_unlock,
scm_mutex_destroy, scm_cond_init, scm_cond_wait, scm_cond_signal,
scm_cond_destroy): New C interface to mutecis and cond vars.

diff --git a/libguile/coop-defs.h b/libguile/coop-defs.h
index dc15136..1fd6ddf 100644 (file)
--- a/libguile/coop-defs.h
+++ b/libguile/coop-defs.h
@@ -108,6 +108,55 @@ typedef struct coop_t {
 
 } coop_t;
 
+/* A queue is a circular list of threads.  The queue head is a
+   designated list element.  If this is a uniprocessor-only
+   implementation we can store the `main' thread in this, but in a
+   multiprocessor there are several `heavy' threads but only one run
+   queue.  A fancier implementation might have private run queues,
+   which would lead to a simpler (trivial) implementation */
+
+typedef struct coop_q_t {
+  coop_t t;
+  coop_t *tail;
+} coop_q_t;
+
+/* A Mutex variable is made up of a owner thread, and a queue of threads
+   waiting on the mutex */
+
+typedef struct coop_m {
+  coop_t *owner;          /* Mutex owner */
+  coop_q_t waiting;      /* Queue of waiting threads */
+} coop_m;
+
+typedef coop_m scm_mutex_t;
+
+extern int coop_mutex_init (coop_m*);
+extern int coop_mutex_lock (coop_m*);
+extern int coop_mutex_unlock (coop_m*);
+extern int coop_mutex_destroy (coop_m*);
+#define scm_mutex_init coop_mutex_init
+#define scm_mutex_lock coop_mutex_lock
+#define scm_mutex_unlock coop_mutex_unlock
+#define scm_mutex_destroy coop_mutex_destroy
+
+/* A Condition variable is made up of a list of threads waiting on the
+   condition. */
+
+typedef struct coop_c {
+  coop_q_t waiting;      /* Queue of waiting threads */
+} coop_c;
+
+typedef coop_c scm_cond_t;
+
+extern int coop_condition_variable_init (coop_c*);
+extern int coop_condition_variable_wait_mutex (coop_c*, coop_m*);
+extern int coop_condition_variable_signal (coop_c*);
+extern int coop_condition_variable_destroy (coop_c*);
+#define scm_cond_init(cond, attr) coop_condition_variable_init (cond)
+#define scm_cond_wait coop_condition_variable_wait_mutex
+#define scm_cond_signal coop_condition_variable_signal
+#define scm_cond_destroy coop_condition_variable_destroy
+
 extern coop_t *coop_global_curr;               /* Currently-executing thread. */
 
 extern void coop_yield (void);

diff --git a/libguile/coop-threads.c b/libguile/coop-threads.c
index 9e1ad75..80c011f 100644 (file)
--- a/libguile/coop-threads.c
+++ b/libguile/coop-threads.c
@@ -501,9 +501,8 @@ scm_wait_condition_variable (c, m)
              m,
              SCM_ARG2,
              s_wait_condition_variable);
-  coop_mutex_unlock (SCM_MUTEX_DATA (m));
-  coop_condition_variable_wait (SCM_CONDVAR_DATA (c));
-  coop_mutex_lock (SCM_MUTEX_DATA (m));
+  coop_condition_variable_wait_mutex (SCM_CONDVAR_DATA (c),
+                                     SCM_MUTEX_DATA (m));
   return SCM_BOOL_T;
 }
 

diff --git a/libguile/coop-threads.h b/libguile/coop-threads.h
index b57dbbf..8c28831 100644 (file)
--- a/libguile/coop-threads.h
+++ b/libguile/coop-threads.h
@@ -74,33 +74,6 @@
  * purpose.
  */
 
-/* A queue is a circular list of threads.  The queue head is a
-   designated list element.  If this is a uniprocessor-only
-   implementation we can store the `main' thread in this, but in a
-   multiprocessor there are several `heavy' threads but only one run
-   queue.  A fancier implementation might have private run queues,
-   which would lead to a simpler (trivial) implementation */
-
-typedef struct coop_q_t {
-  coop_t t;
-  coop_t *tail;
-} coop_q_t;
-
-/* A Mutex variable is made up of a owner thread, and a queue of threads
-   waiting on the mutex */
-
-typedef struct coop_m {
-  coop_t *owner;          /* Mutex owner */
-  coop_q_t waiting;      /* Queue of waiting threads */
-} coop_m;
-
-/* A Condition variable is made up of a list of threads waiting on the
-   condition. */
-
-typedef struct coop_c {
-  coop_q_t waiting;      /* Queue of waiting threads */
-} coop_c;
-
 /* Each thread starts by calling a user-supplied function of this
    type. */
 

diff --git a/libguile/coop.c b/libguile/coop.c
index 81f0e3d..a2c7cd5 100644 (file)
--- a/libguile/coop.c
+++ b/libguile/coop.c
@@ -40,7 +40,7 @@
  * If you do not wish that, delete this exception notice.  */
 \f
 
-/* $Id: coop.c,v 1.3 1997-11-27 18:04:53 mdj Exp $ */
+/* $Id: coop.c,v 1.4 1998-01-26 01:43:16 mdj Exp $ */
 
 /* Cooperative thread library, based on QuickThreads */
 
@@ -262,23 +262,24 @@ coop_starthelp (old, ignore0, ignore1)
 }
 
 #ifdef __STDC__
-void 
+int
 coop_mutex_init (coop_m *m)
 #else
-void 
+int
 coop_mutex_init (m)
      coop_m *m;
 #endif
 {
   m->owner = NULL;
   coop_qinit(&(m->waiting));
+  return 0;
 }
 
 #ifdef __STDC__
-void 
+int
 coop_mutex_lock (coop_m *m)
 #else
-void 
+int 
 coop_mutex_lock ()
      coop_m *m;
 #endif
@@ -303,14 +304,15 @@ coop_mutex_lock ()
       coop_global_curr = newthread;
       QT_BLOCK (coop_yieldhelp, old, &(m->waiting), newthread->sp);
     }
+  return 0;
 }
 
 
 #ifdef __STDC__
-void 
+int 
 coop_mutex_unlock (coop_m *m)
 #else
-void 
+int 
 coop_mutex_unlock (m)
      coop_m *m;
 #endif
@@ -332,26 +334,41 @@ coop_mutex_unlock (m)
     {
       m->owner = NULL;
     }
+  return 0;
 }
 
 
 #ifdef __STDC__
-void 
+int 
+coop_mutex_destroy (coop_m *m)
+#else
+int 
+coop_mutex_destroy (m)
+     coop_m *m;
+#endif
+{
+  return 0;
+}
+
+
+#ifdef __STDC__
+int 
 coop_condition_variable_init (coop_c *c)
 #else
-void 
+int 
 coop_condition_variable_init (c)
      coop_c *c;
 #endif
 {
   coop_qinit(&(c->waiting));
+  return 0;
 }
 
 #ifdef __STDC__
-void 
+int 
 coop_condition_variable_wait (coop_c *c)
 #else
-void 
+int 
 coop_condition_variable_wait (c)
      coop_c *c;
 #endif
@@ -366,13 +383,32 @@ coop_condition_variable_wait (c)
   old = coop_global_curr;
   coop_global_curr = newthread;
   QT_BLOCK (coop_yieldhelp, old, &(c->waiting), newthread->sp);
+  return 0;
+}
+
+
+#ifdef __STDC__
+int 
+coop_condition_variable_wait_mutex (coop_c *c, coop_m *m)
+#else
+int 
+coop_condition_variable_wait_mutex (c, m)
+     coop_c *c;
+     coop_m *m;
+#endif
+{
+  coop_mutex_unlock (m);
+  coop_condition_variable_wait (c);
+  coop_mutex_lock (m);
+  return 0;
 }
 
+
 #ifdef __STDC__
-void 
+int 
 coop_condition_variable_signal (coop_c *c)
 #else
-void 
+int 
 coop_condition_variable_signal (c)
      coop_c *c;
 #endif
@@ -383,6 +419,20 @@ coop_condition_variable_signal (c)
     {
       coop_qput (&coop_global_runq, newthread);
     }
+  return 0;
+}
+
+
+#ifdef __STDC__
+int 
+coop_condition_variable_destroy (coop_c *c)
+#else
+int 
+coop_condition_variable_destroy (c)
+     coop_c *c;
+#endif
+{
+  return 0;
 }