X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Frts%2FRtsAPI.c;h=4f7e783595700daf2c87408f6f3ea260c68935eb;hb=7bd8a0491055e7ca5709109400459556e870250a;hp=7bfb9d889f84b076b2d46ba46299085edc4038d0;hpb=286a25bb4e6c5baf8900874300dc095705d84918;p=ghc-hetmet.git

diff --git a/ghc/rts/RtsAPI.c b/ghc/rts/RtsAPI.c
index 7bfb9d8..4f7e783 100644
--- a/ghc/rts/RtsAPI.c
+++ b/ghc/rts/RtsAPI.c
@@ -1,5 +1,5 @@
 /* ----------------------------------------------------------------------------
- * $Id: RtsAPI.c,v 1.37 2002/12/02 14:33:10 simonmar Exp $
+ * $Id: RtsAPI.c,v 1.44 2003/05/23 08:28:48 simonmar Exp $
  *
  * (c) The GHC Team, 1998-2001
  *
@@ -17,50 +17,9 @@
 #include "Prelude.h"
 #include "OSThreads.h"
 #include "Schedule.h"
+#include "Capability.h"
 
-#if defined(RTS_SUPPORTS_THREADS)
-/* Cheesy locking scheme while waiting for the 
- * RTS API to change.
- */
-static Mutex     alloc_mutex = INIT_MUTEX_VAR;
-static Condition alloc_cond  = INIT_COND_VAR;
-#define INVALID_THREAD_ID ((OSThreadId)(-1))
-
-/* Thread currently owning the allocator */
-static OSThreadId c_id = INVALID_THREAD_ID;
-
-static StgPtr alloc(nat n)
-{
-  OSThreadId tid = osThreadId();
-  ACQUIRE_LOCK(&alloc_mutex);
-  if (tid == c_id) {
-    /* I've got the lock, just allocate() */
-    ;
-  } else if (c_id == INVALID_THREAD_ID) {
-    c_id = tid;
-  } else {
-    waitCondition(&alloc_cond, &alloc_mutex);
-    c_id = tid;
-  }
-  RELEASE_LOCK(&alloc_mutex);
-  return allocate(n);
-}
-
-static void releaseAllocLock(void)
-{
-  ACQUIRE_LOCK(&alloc_mutex);
-  /* Reset the allocator owner */
-  c_id = INVALID_THREAD_ID;
-  RELEASE_LOCK(&alloc_mutex);
-
-  /* Free up an OS thread waiting to get in */
-  signalCondition(&alloc_cond);
-}
-#else
-# define alloc(n) allocate(n)
-# define releaseAllocLock() /* nothing */
-#endif
-
+#include <stdlib.h>
 
 /* ----------------------------------------------------------------------------
    Building Haskell objects from C datatypes.
@@ -68,7 +27,7 @@ static void releaseAllocLock(void)
 HaskellObj
 rts_mkChar (HsChar c)
 {
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,1));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, Czh_con_info, CCS_SYSTEM);
   p->payload[0]  = (StgClosure *)(StgChar)c;
   return p;
@@ -77,7 +36,7 @@ rts_mkChar (HsChar c)
 HaskellObj
 rts_mkInt (HsInt i)
 {
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,1));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, Izh_con_info, CCS_SYSTEM);
   p->payload[0]  = (StgClosure *)(StgInt)i;
   return p;
@@ -86,7 +45,7 @@ rts_mkInt (HsInt i)
 HaskellObj
 rts_mkInt8 (HsInt8 i)
 {
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,1));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, I8zh_con_info, CCS_SYSTEM);
   /* Make sure we mask out the bits above the lowest 8 */
   p->payload[0]  = (StgClosure *)(StgInt)((unsigned)i & 0xff);
@@ -96,7 +55,7 @@ rts_mkInt8 (HsInt8 i)
 HaskellObj
 rts_mkInt16 (HsInt16 i)
 {
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,1));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, I16zh_con_info, CCS_SYSTEM);
   /* Make sure we mask out the relevant bits */
   p->payload[0]  = (StgClosure *)(StgInt)((unsigned)i & 0xffff);
@@ -106,7 +65,7 @@ rts_mkInt16 (HsInt16 i)
 HaskellObj
 rts_mkInt32 (HsInt32 i)
 {
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,1));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, I32zh_con_info, CCS_SYSTEM);
   p->payload[0]  = (StgClosure *)(StgInt)((unsigned)i & 0xffffffff);
   return p;
@@ -116,7 +75,7 @@ HaskellObj
 rts_mkInt64 (HsInt64 i)
 {
   long long *tmp;
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,2));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,2));
   SET_HDR(p, I64zh_con_info, CCS_SYSTEM);
   tmp  = (long long*)&(p->payload[0]);
   *tmp = (StgInt64)i;
@@ -126,7 +85,7 @@ rts_mkInt64 (HsInt64 i)
 HaskellObj
 rts_mkWord (HsWord i)
 {
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,1));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, Wzh_con_info, CCS_SYSTEM);
   p->payload[0]  = (StgClosure *)(StgWord)i;
   return p;
@@ -136,7 +95,7 @@ HaskellObj
 rts_mkWord8 (HsWord8 w)
 {
   /* see rts_mkInt* comments */
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,1));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, W8zh_con_info, CCS_SYSTEM);
   p->payload[0]  = (StgClosure *)(StgWord)(w & 0xff);
   return p;
@@ -146,7 +105,7 @@ HaskellObj
 rts_mkWord16 (HsWord16 w)
 {
   /* see rts_mkInt* comments */
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,1));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, W16zh_con_info, CCS_SYSTEM);
   p->payload[0]  = (StgClosure *)(StgWord)(w & 0xffff);
   return p;
@@ -156,7 +115,7 @@ HaskellObj
 rts_mkWord32 (HsWord32 w)
 {
   /* see rts_mkInt* comments */
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,1));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, W32zh_con_info, CCS_SYSTEM);
   p->payload[0]  = (StgClosure *)(StgWord)(w & 0xffffffff);
   return p;
@@ -167,7 +126,7 @@ rts_mkWord64 (HsWord64 w)
 {
   unsigned long long *tmp;
 
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,2));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,2));
   /* see mk_Int8 comment */
   SET_HDR(p, W64zh_con_info, CCS_SYSTEM);
   tmp  = (unsigned long long*)&(p->payload[0]);
@@ -178,7 +137,7 @@ rts_mkWord64 (HsWord64 w)
 HaskellObj
 rts_mkFloat (HsFloat f)
 {
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,1));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,1));
   SET_HDR(p, Fzh_con_info, CCS_SYSTEM);
   ASSIGN_FLT((P_)p->payload, (StgFloat)f);
   return p;
@@ -187,7 +146,7 @@ rts_mkFloat (HsFloat f)
 HaskellObj
 rts_mkDouble (HsDouble d)
 {
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,sizeofW(StgDouble)));
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,sizeofW(StgDouble)));
   SET_HDR(p, Dzh_con_info, CCS_SYSTEM);
   ASSIGN_DBL((P_)p->payload, (StgDouble)d);
   return p;
@@ -196,7 +155,7 @@ rts_mkDouble (HsDouble d)
 HaskellObj
 rts_mkStablePtr (HsStablePtr s)
 {
-  StgClosure *p = (StgClosure *)alloc(sizeofW(StgHeader)+1);
+  StgClosure *p = (StgClosure *)allocate(sizeofW(StgHeader)+1);
   SET_HDR(p, StablePtr_con_info, CCS_SYSTEM);
   p->payload[0]  = (StgClosure *)s;
   return p;
@@ -205,13 +164,21 @@ rts_mkStablePtr (HsStablePtr s)
 HaskellObj
 rts_mkPtr (HsPtr a)
 {
-  StgClosure *p = (StgClosure *)alloc(sizeofW(StgHeader)+1);
+  StgClosure *p = (StgClosure *)allocate(sizeofW(StgHeader)+1);
   SET_HDR(p, Ptr_con_info, CCS_SYSTEM);
   p->payload[0]  = (StgClosure *)a;
   return p;
 }
 
-#ifdef COMPILER /* GHC has em, Hugs doesn't */
+HaskellObj
+rts_mkFunPtr (HsFunPtr a)
+{
+  StgClosure *p = (StgClosure *)allocate(sizeofW(StgHeader)+1);
+  SET_HDR(p, FunPtr_con_info, CCS_SYSTEM);
+  p->payload[0]  = (StgClosure *)a;
+  return p;
+}
+
 HaskellObj
 rts_mkBool (HsBool b)
 {
@@ -227,14 +194,13 @@ rts_mkString (char *s)
 {
   return rts_apply((StgClosure *)unpackCString_closure, rts_mkPtr(s));
 }
-#endif /* COMPILER */
 
 HaskellObj
 rts_apply (HaskellObj f, HaskellObj arg)
 {
     StgClosure *ap;
 
-    ap = (StgClosure *)alloc(sizeofW(StgClosure) + 2);
+    ap = (StgClosure *)allocate(sizeofW(StgClosure) + 2);
     SET_HDR(ap, (StgInfoTable *)&stg_ap_2_upd_info, CCS_SYSTEM);
     ap->payload[0] = f;
     ap->payload[1] = arg;
@@ -389,7 +355,15 @@ rts_getPtr (HaskellObj p)
     return (void *)(p->payload[0]);
 }
 
-#ifdef COMPILER /* GHC has em, Hugs doesn't */
+HsFunPtr
+rts_getFunPtr (HaskellObj p)
+{
+    // See comment above:
+    // ASSERT(p->header.info == FunPtr_con_info ||
+    //        p->header.info == FunPtr_static_info);
+    return (void *)(p->payload[0]);
+}
+
 HsBool
 rts_getBool (HaskellObj p)
 {
@@ -401,7 +375,6 @@ rts_getBool (HaskellObj p)
     barf("rts_getBool: not a Bool");
   }
 }
-#endif /* COMPILER */
 
 /* ----------------------------------------------------------------------------
    Evaluating Haskell expressions
@@ -412,7 +385,6 @@ rts_eval (HaskellObj p, /*out*/HaskellObj *ret)
     StgTSO *tso;
 
     tso = createGenThread(RtsFlags.GcFlags.initialStkSize, p);
-    releaseAllocLock();
     return scheduleWaitThread(tso,ret);
 }
 
@@ -422,7 +394,6 @@ rts_eval_ (HaskellObj p, unsigned int stack_size, /*out*/HaskellObj *ret)
     StgTSO *tso;
     
     tso = createGenThread(stack_size, p);
-    releaseAllocLock();
     return scheduleWaitThread(tso,ret);
 }
 
@@ -436,21 +407,20 @@ rts_evalIO (HaskellObj p, /*out*/HaskellObj *ret)
     StgTSO* tso; 
     
     tso = createStrictIOThread(RtsFlags.GcFlags.initialStkSize, p);
-    releaseAllocLock();
     return scheduleWaitThread(tso,ret);
 }
 
 /*
- * Identical to rts_evalIO(), but won't create a new task/OS thread
+ * Identical to rts_evalLazyIO(), but won't create a new task/OS thread
  * to evaluate the Haskell thread. Used by main() only. Hack.
  */
+ 
 SchedulerStatus
-rts_mainEvalIO(HaskellObj p, /*out*/HaskellObj *ret)
+rts_mainLazyIO(HaskellObj p, /*out*/HaskellObj *ret)
 {
-    StgTSO* tso; 
+    StgTSO* tso;
     
-    tso = createStrictIOThread(RtsFlags.GcFlags.initialStkSize, p);
-    releaseAllocLock();
+    tso = createIOThread(RtsFlags.GcFlags.initialStkSize, p);
     scheduleThread(tso);
     return waitThread(tso, ret);
 }
@@ -470,7 +440,6 @@ rts_evalStableIO (HsStablePtr s, /*out*/HsStablePtr *ret)
     
     p = (StgClosure *)deRefStablePtr(s);
     tso = createStrictIOThread(RtsFlags.GcFlags.initialStkSize, p);
-    releaseAllocLock();
     stat = scheduleWaitThread(tso,&r);
 
     if (stat == Success) {
@@ -490,7 +459,6 @@ rts_evalLazyIO (HaskellObj p, unsigned int stack_size, /*out*/HaskellObj *ret)
     StgTSO *tso;
 
     tso = createIOThread(stack_size, p);
-    releaseAllocLock();
     return scheduleWaitThread(tso,ret);
 }
 
@@ -503,10 +471,46 @@ rts_checkSchedStatus ( char* site, SchedulerStatus rc )
     case Success:
 	return;
     case Killed:
-	barf("%s: uncaught exception",site);
+	prog_belch("%s: uncaught exception",site);
+	stg_exit(EXIT_FAILURE);
     case Interrupted:
-	barf("%s: interrupted", site);
+	prog_belch("%s: interrupted", site);
+	stg_exit(EXIT_FAILURE);
     default:
-	barf("%s: Return code (%d) not ok",(site),(rc));	
+	prog_belch("%s: Return code (%d) not ok",(site),(rc));	
+	stg_exit(EXIT_FAILURE);
     }
 }
+
+void
+rts_lock()
+{
+#ifdef RTS_SUPPORTS_THREADS
+	Capability *cap;
+	ACQUIRE_LOCK(&sched_mutex);
+	
+		// we request to get the capability immediately, in order to
+		// a) stop other threads from using allocate()
+		// b) wake the current worker thread from awaitEvent()
+		//       (so that a thread started by rts_eval* will start immediately)
+	grabReturnCapability(&sched_mutex,&cap);
+	
+		// now that we have the capability, we don't need it anymore
+		// (other threads will continue to run as soon as we release the sched_mutex)
+	releaseCapability(cap);
+	
+		// In the RTS hasn't been entered yet,
+		// start a RTS task.
+		// If there is already a task available (waiting for the work capability),
+		// this will do nothing.
+	startSchedulerTask();
+#endif
+}
+
+void
+rts_unlock()
+{
+#ifdef RTS_SUPPORTS_THREADS
+	RELEASE_LOCK(&sched_mutex);
+#endif
+}