X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2FCapability.c;h=9294949e5bc57067bdeaca399a892af6d4c8306a;hb=d8b99b7e9b2ce9fd8ba97fa10657082ceac09c59;hp=4264f0ff573afa9f043bb2c2907be814d88ec1e2;hpb=c51229b2bfd3b1a61d3966db894210ef848f0a6d;p=ghc-hetmet.git

diff --git a/rts/Capability.c b/rts/Capability.c
index 4264f0f..9294949 100644
--- a/rts/Capability.c
+++ b/rts/Capability.c
@@ -77,37 +77,40 @@ findSpark (Capability *cap)
   rtsBool retry;
   nat i = 0;
 
-  if (!emptyRunQueue(cap)) {
+  if (!emptyRunQueue(cap) || cap->returning_tasks_hd != NULL) {
       // If there are other threads, don't try to run any new
       // sparks: sparks might be speculative, we don't want to take
       // resources away from the main computation.
       return 0;
   }
 
-  // first try to get a spark from our own pool.
-  // We should be using reclaimSpark(), because it works without
-  // needing any atomic instructions:
-  //   spark = reclaimSpark(cap->sparks);
-  // However, measurements show that this makes at least one benchmark
-  // slower (prsa) and doesn't affect the others.
-  spark = tryStealSpark(cap);
-  if (spark != NULL) {
-      cap->sparks_converted++;
+  do {
+      retry = rtsFalse;
 
-      // Post event for running a spark from capability's own pool.
-      postEvent(cap, EVENT_RUN_SPARK, cap->r.rCurrentTSO->id, 0);
+      // first try to get a spark from our own pool.
+      // We should be using reclaimSpark(), because it works without
+      // needing any atomic instructions:
+      //   spark = reclaimSpark(cap->sparks);
+      // However, measurements show that this makes at least one benchmark
+      // slower (prsa) and doesn't affect the others.
+      spark = tryStealSpark(cap);
+      if (spark != NULL) {
+          cap->sparks_converted++;
 
-      return spark;
-  }
+          // Post event for running a spark from capability's own pool.
+          traceSchedEvent(cap, EVENT_RUN_SPARK, cap->r.rCurrentTSO, 0);
 
-  if (n_capabilities == 1) { return NULL; } // makes no sense...
+          return spark;
+      }
+      if (!emptySparkPoolCap(cap)) {
+          retry = rtsTrue;
+      }
 
-  debugTrace(DEBUG_sched,
-	     "cap %d: Trying to steal work from other capabilities", 
-	     cap->no);
+      if (n_capabilities == 1) { return NULL; } // makes no sense...
 
-  do {
-      retry = rtsFalse;
+      debugTrace(DEBUG_sched,
+                 "cap %d: Trying to steal work from other capabilities", 
+                 cap->no);
 
       /* visit cap.s 0..n-1 in sequence until a theft succeeds. We could
       start at a random place instead of 0 as well.  */
@@ -127,14 +130,10 @@ findSpark (Capability *cap)
           }
 
           if (spark != NULL) {
-              debugTrace(DEBUG_sched,
-		 "cap %d: Stole a spark from capability %d",
-                         cap->no, robbed->no);
               cap->sparks_converted++;
 
-              postEvent(cap, EVENT_STEAL_SPARK, 
-                        cap->r.rCurrentTSO->id, robbed->no);
-                        
+              traceSchedEvent(cap, EVENT_STEAL_SPARK, 
+                              cap->r.rCurrentTSO, robbed->no);
               
               return spark;
           }
@@ -580,10 +579,9 @@ yieldCapability (Capability** pCap, Task *task)
     Capability *cap = *pCap;
 
     if (waiting_for_gc == PENDING_GC_PAR) {
-	debugTrace(DEBUG_sched, "capability %d: becoming a GC thread", cap->no);
-        postEvent(cap, EVENT_GC_START, 0, 0);
+        traceSchedEvent(cap, EVENT_GC_START, 0, 0);
         gcWorkerThread(cap);
-        postEvent(cap, EVENT_GC_END, 0, 0);
+        traceSchedEvent(cap, EVENT_GC_END, 0, 0);
         return;
     }
 
@@ -790,8 +788,7 @@ shutdownCapability (Capability *cap, Task *task, rtsBool safe)
             continue;
         }
             
-        postEvent(cap, EVENT_SHUTDOWN, 0, 0);
-	debugTrace(DEBUG_sched, "capability %d is stopped.", cap->no);
+        traceSchedEvent(cap, EVENT_SHUTDOWN, 0, 0);
 	RELEASE_LOCK(&cap->lock);
 	break;
     }
@@ -880,8 +877,6 @@ markSomeCapabilities (evac_fn evac, void *user, nat i0, nat delta,
 #endif
 	for (task = cap->suspended_ccalling_tasks; task != NULL; 
 	     task=task->next) {
-	    debugTrace(DEBUG_sched,
-		       "evac'ing suspended TSO %lu", (unsigned long)task->suspended_tso->id);
 	    evac(user, (StgClosure **)(void *)&task->suspended_tso);
 	}