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

diff --git a/ghc/rts/RtsAPI.c b/ghc/rts/RtsAPI.c
index 7bfb9d8..4ca1225 100644
--- a/ghc/rts/RtsAPI.c
+++ b/ghc/rts/RtsAPI.c
@@ -1,5 +1,4 @@
 /* ----------------------------------------------------------------------------
- * $Id: RtsAPI.c,v 1.37 2002/12/02 14:33:10 simonmar Exp $
  *
  * (c) The GHC Team, 1998-2001
  *
@@ -17,50 +16,11 @@
 #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>
 
+static Capability *rtsApiCapability = NULL;
 
 /* ----------------------------------------------------------------------------
    Building Haskell objects from C datatypes.
@@ -68,16 +28,16 @@ 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;
+  p->payload[0]  = (StgClosure *)(StgWord)(StgChar)c;
   return p;
 }
 
 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 +46,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 +56,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 +66,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;
@@ -115,10 +75,10 @@ rts_mkInt32 (HsInt32 i)
 HaskellObj
 rts_mkInt64 (HsInt64 i)
 {
-  long long *tmp;
-  StgClosure *p = (StgClosure *)alloc(CONSTR_sizeW(0,2));
+  llong *tmp;
+  StgClosure *p = (StgClosure *)allocate(CONSTR_sizeW(0,2));
   SET_HDR(p, I64zh_con_info, CCS_SYSTEM);
-  tmp  = (long long*)&(p->payload[0]);
+  tmp  = (llong*)&(p->payload[0]);
   *tmp = (StgInt64)i;
   return p;
 }
@@ -126,7 +86,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 +96,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 +106,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 +116,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;
@@ -165,12 +125,12 @@ rts_mkWord32 (HsWord32 w)
 HaskellObj
 rts_mkWord64 (HsWord64 w)
 {
-  unsigned long long *tmp;
+  ullong *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]);
+  tmp  = (ullong*)&(p->payload[0]);
   *tmp = (StgWord64)w;
   return p;
 }
@@ -178,7 +138,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 +147,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 +156,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 +165,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 +195,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;
@@ -292,7 +259,7 @@ rts_getInt32 (HaskellObj p)
     // See comment above:
     // ASSERT(p->header.info == I32zh_con_info ||
     //        p->header.info == I32zh_static_info);
-    return (HsInt32)(p->payload[0]);
+    return (HsInt32)(HsInt)(p->payload[0]);
 }
 
 HsInt64
@@ -338,7 +305,7 @@ rts_getWord32 (HaskellObj p)
     // See comment above:
     // ASSERT(p->header.info == W32zh_con_info ||
     //        p->header.info == W32zh_static_info);
-    return (HsWord32)(p->payload[0]);
+    return (HsWord32)(HsWord)(p->payload[0]);
 }
 
 
@@ -389,19 +356,27 @@ 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)
 {
-  if (p == True_closure) {
-    return 1;
-  } else if (p == False_closure) {
-    return 0;
-  } else {
-    barf("rts_getBool: not a Bool");
-  }
+    StgInfoTable *info;
+
+    info = get_itbl((StgClosure *)p);
+    if (info->srt_bitmap == 0) { // srt_bitmap is the constructor tag
+	return 0;
+    } else {
+	return 1;
+    }
 }
-#endif /* COMPILER */
 
 /* ----------------------------------------------------------------------------
    Evaluating Haskell expressions
@@ -410,20 +385,22 @@ SchedulerStatus
 rts_eval (HaskellObj p, /*out*/HaskellObj *ret)
 {
     StgTSO *tso;
+    Capability *cap = rtsApiCapability;
+    rtsApiCapability = NULL;
 
     tso = createGenThread(RtsFlags.GcFlags.initialStkSize, p);
-    releaseAllocLock();
-    return scheduleWaitThread(tso,ret);
+    return scheduleWaitThread(tso,ret,cap);
 }
 
 SchedulerStatus
 rts_eval_ (HaskellObj p, unsigned int stack_size, /*out*/HaskellObj *ret)
 {
     StgTSO *tso;
+    Capability *cap = rtsApiCapability;
+    rtsApiCapability = NULL;
     
     tso = createGenThread(stack_size, p);
-    releaseAllocLock();
-    return scheduleWaitThread(tso,ret);
+    return scheduleWaitThread(tso,ret,cap);
 }
 
 /*
@@ -434,25 +411,11 @@ SchedulerStatus
 rts_evalIO (HaskellObj p, /*out*/HaskellObj *ret)
 {
     StgTSO* tso; 
+    Capability *cap = rtsApiCapability;
+    rtsApiCapability = NULL;
     
     tso = createStrictIOThread(RtsFlags.GcFlags.initialStkSize, p);
-    releaseAllocLock();
-    return scheduleWaitThread(tso,ret);
-}
-
-/*
- * Identical to rts_evalIO(), 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)
-{
-    StgTSO* tso; 
-    
-    tso = createStrictIOThread(RtsFlags.GcFlags.initialStkSize, p);
-    releaseAllocLock();
-    scheduleThread(tso);
-    return waitThread(tso, ret);
+    return scheduleWaitThread(tso,ret,cap);
 }
 
 /*
@@ -467,13 +430,14 @@ rts_evalStableIO (HsStablePtr s, /*out*/HsStablePtr *ret)
     StgTSO* tso;
     StgClosure *p, *r;
     SchedulerStatus stat;
+    Capability *cap = rtsApiCapability;
+    rtsApiCapability = NULL;
     
     p = (StgClosure *)deRefStablePtr(s);
     tso = createStrictIOThread(RtsFlags.GcFlags.initialStkSize, p);
-    releaseAllocLock();
-    stat = scheduleWaitThread(tso,&r);
+    stat = scheduleWaitThread(tso,&r,cap);
 
-    if (stat == Success) {
+    if (stat == Success && ret != NULL) {
 	ASSERT(r != NULL);
 	*ret = getStablePtr((StgPtr)r);
     }
@@ -485,13 +449,25 @@ rts_evalStableIO (HsStablePtr s, /*out*/HsStablePtr *ret)
  * Like rts_evalIO(), but doesn't force the action's result.
  */
 SchedulerStatus
-rts_evalLazyIO (HaskellObj p, unsigned int stack_size, /*out*/HaskellObj *ret)
+rts_evalLazyIO (HaskellObj p, /*out*/HaskellObj *ret)
+{
+    StgTSO *tso;
+    Capability *cap = rtsApiCapability;
+    rtsApiCapability = NULL;
+
+    tso = createIOThread(RtsFlags.GcFlags.initialStkSize, p);
+    return scheduleWaitThread(tso,ret,cap);
+}
+
+SchedulerStatus
+rts_evalLazyIO_ (HaskellObj p, unsigned int stack_size, /*out*/HaskellObj *ret)
 {
     StgTSO *tso;
+    Capability *cap = rtsApiCapability;
+    rtsApiCapability = NULL;
 
     tso = createIOThread(stack_size, p);
-    releaseAllocLock();
-    return scheduleWaitThread(tso,ret);
+    return scheduleWaitThread(tso,ret,cap);
 }
 
 /* Convenience function for decoding the returned status. */
@@ -503,10 +479,39 @@ rts_checkSchedStatus ( char* site, SchedulerStatus rc )
     case Success:
 	return;
     case Killed:
-	barf("%s: uncaught exception",site);
+	errorBelch("%s: uncaught exception",site);
+	stg_exit(EXIT_FAILURE);
     case Interrupted:
-	barf("%s: interrupted", site);
+	errorBelch("%s: interrupted", site);
+	stg_exit(EXIT_FAILURE);
     default:
-	barf("%s: Return code (%d) not ok",(site),(rc));	
+	errorBelch("%s: Return code (%d) not ok",(site),(rc));	
+	stg_exit(EXIT_FAILURE);
+    }
+}
+
+void
+rts_lock()
+{
+#ifdef RTS_SUPPORTS_THREADS
+    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)
+    waitForReturnCapability(&sched_mutex,&rtsApiCapability);
+#endif
+}
+
+void
+rts_unlock()
+{
+#ifdef RTS_SUPPORTS_THREADS
+    if (rtsApiCapability) {
+	releaseCapability(rtsApiCapability);
     }
+    rtsApiCapability = NULL;
+    RELEASE_LOCK(&sched_mutex);
+#endif
 }