[project @ 2003-12-15 16:43:45 by simonmar]

[ghc-hetmet.git] / ghc / rts / Capability.c

diff --git a/ghc/rts/Capability.c b/ghc/rts/Capability.c
index d748aee..1d78982 100644 (file)
--- a/ghc/rts/Capability.c
+++ b/ghc/rts/Capability.c
@@ -69,6 +69,9 @@ Condition thread_ready_cond = INIT_COND_VAR;
  * Task.startTask() uses its current value.
  */
 nat rts_n_waiting_tasks = 0;
+
+static Condition *passTarget = NULL;
+static rtsBool passingCapability = rtsFalse;
 #endif
 
 /* -----------------------------------------------------------------------------
@@ -137,10 +140,8 @@ static Capability *returning_capabilities;
  */ 
 void grabCapability(Capability** cap)
 {
-#ifdef RTS_SUPPORTS_THREADS
-  ASSERT(rts_n_free_capabilities > 0);
-#endif
 #if !defined(SMP)
+  ASSERT(rts_n_free_capabilities == 1);
   rts_n_free_capabilities = 0;
   *cap = &MainCapability;
   handleSignalsInThisThread();
@@ -150,9 +151,7 @@ void grabCapability(Capability** cap)
   rts_n_free_capabilities--;
 #endif
 #ifdef RTS_SUPPORTS_THREADS
-  IF_DEBUG(scheduler,
-          fprintf(stderr,"worker thread (%p): got capability\n",
-                  osThreadId()));
+    IF_DEBUG(scheduler, sched_belch("worker: got capability"));
 #endif
 }
 
@@ -189,6 +188,7 @@ void releaseCapability(Capability* cap
 #endif
     rts_n_waiting_workers--;
     signalCondition(&returning_worker_cond);
+    IF_DEBUG(scheduler, sched_belch("worker: released capability to returning worker"));
   } else /*if ( !EMPTY_RUN_QUEUE() )*/ {
 #if defined(SMP)
     cap->link = free_capabilities;
@@ -201,14 +201,10 @@ void releaseCapability(Capability* cap
     signalCondition(&thread_ready_cond);
     startSchedulerTaskIfNecessary();  // if there is more work to be done,
                                      // we'll need a new thread
+    IF_DEBUG(scheduler, sched_belch("worker: released capability"));
   }
 #endif
-#ifdef RTS_SUPPORTS_THREADS
-  IF_DEBUG(scheduler,
-          fprintf(stderr,"worker thread (%p): released capability\n",
-                  osThreadId()));
-#endif
- return;
+  return;
 }
 
 #if defined(RTS_SUPPORTS_THREADS)
@@ -247,12 +243,10 @@ void releaseCapability(Capability* cap
 void
 grabReturnCapability(Mutex* pMutex, Capability** pCap)
 {
-  IF_DEBUG(scheduler,
-          fprintf(stderr,"worker (%p): returning, waiting for lock.\n", osThreadId()));
-  IF_DEBUG(scheduler,
-          fprintf(stderr,"worker (%p): returning; workers waiting: %d\n",
-                  osThreadId(), rts_n_waiting_workers));
-  if ( noCapabilities() ) {
+  IF_DEBUG(scheduler, 
+          sched_belch("worker: returning; workers waiting: %d",
+                      rts_n_waiting_workers));
+  if ( noCapabilities() || passingCapability ) {
     rts_n_waiting_workers++;
     wakeBlockedWorkerThread();
     context_switch = 1;        // make sure it's our turn soon
@@ -296,14 +290,12 @@ void
 yieldToReturningWorker(Mutex* pMutex, Capability** pCap, Condition* pThreadCond)
 {
   if ( rts_n_waiting_workers > 0 ) {
-    IF_DEBUG(scheduler,
-            fprintf(stderr,"worker thread (%p): giving up RTS token\n", osThreadId()));
+    IF_DEBUG(scheduler, sched_belch("worker: giving up capability"));
     releaseCapability(*pCap);
         /* And wait for work */
     waitForWorkCapability(pMutex, pCap, pThreadCond);
     IF_DEBUG(scheduler,
-            fprintf(stderr,"worker thread (%p): got back RTS token (after yieldToReturningWorker)\n",
-               osThreadId()));
+            sched_belch("worker: got back capability (after yieldToReturningWorker)"));
   }
   return;
 }
@@ -325,34 +317,27 @@ yieldToReturningWorker(Mutex* pMutex, Capability** pCap, Condition* pThreadCond)
  * Post-condition: pMutex is held and *pCap is held by the current thread
  */
  
-static Condition *passTarget = NULL;
-static rtsBool passingCapability = rtsFalse;
- 
 void 
 waitForWorkCapability(Mutex* pMutex, Capability** pCap, Condition* pThreadCond)
 {
 #ifdef SMP
   #error SMP version not implemented
 #endif
-  IF_DEBUG(scheduler,
-          fprintf(stderr,"worker thread (%p): wait for cap (cond: %p)\n",
-             osThreadId(),pThreadCond));
   while ( noCapabilities() || (passingCapability && passTarget != pThreadCond)) {
+    IF_DEBUG(scheduler,
+            sched_belch("worker: wait for capability (cond: %p)",
+                        pThreadCond));
     if(pThreadCond)
     {
       waitCondition(pThreadCond, pMutex);
-      IF_DEBUG(scheduler,
-              fprintf(stderr,"worker thread (%p): get passed capability\n",
-                 osThreadId()));
+      IF_DEBUG(scheduler, sched_belch("worker: get passed capability"));
     }
     else
     {
       rts_n_waiting_tasks++;
       waitCondition(&thread_ready_cond, pMutex);
       rts_n_waiting_tasks--;
-      IF_DEBUG(scheduler,
-              fprintf(stderr,"worker thread (%p): get normal capability\n",
-                 osThreadId()));
+      IF_DEBUG(scheduler, sched_belch("worker: get normal capability"));
     }
   }
   passingCapability = rtsFalse;
@@ -380,10 +365,8 @@ passCapability(Mutex* pMutex, Capability* cap, Condition *pTargetThreadCond)
     rts_n_free_capabilities = 1;
     signalCondition(pTargetThreadCond);
     passTarget = pTargetThreadCond;
-       passingCapability = rtsTrue;
-    IF_DEBUG(scheduler,
-            fprintf(stderr,"worker thread (%p): passCapability\n",
-               osThreadId()));
+    passingCapability = rtsTrue;
+    IF_DEBUG(scheduler, sched_belch("worker: passCapability"));
 }
 
 /*
@@ -408,9 +391,7 @@ passCapabilityToWorker(Mutex* pMutex, Capability* cap)
     startSchedulerTaskIfNecessary();
     passTarget = NULL;
     passingCapability = rtsTrue;
-    IF_DEBUG(scheduler,
-            fprintf(stderr,"worker thread (%p): passCapabilityToWorker\n",
-               osThreadId()));
+    IF_DEBUG(scheduler, sched_belch("worker: passCapabilityToWorker"));
 }
 
 
@@ -442,7 +423,8 @@ initCapabilities_(nat n)
   free_capabilities = cap;
   rts_n_free_capabilities = n;
   returning_capabilities = NULL;
-  IF_DEBUG(scheduler,fprintf(stderr,"scheduler: Allocated %d capabilities\n", n_free_capabilities););
+  IF_DEBUG(scheduler,
+          sched_belch("allocated %d capabilities", n_free_capabilities));
 }
 #endif /* SMP */