X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=rts%2FCapability.c;h=73a3427d7eb2838f5b443b6370de7411849ebea3;hb=a60af39758448f92d8eaa3b62072f9adcdbbee9d;hp=e384e1edddcb602a4a3c14b8fcb49cd36bf21dc2;hpb=88b35c172f9434fd98b700f706074d142914a8bb;p=ghc-hetmet.git

diff --git a/rts/Capability.c b/rts/Capability.c
index e384e1e..73a3427 100644
--- a/rts/Capability.c
+++ b/rts/Capability.c
@@ -153,7 +153,8 @@ initCapability( Capability *cap, nat i )
 	cap->mut_lists[g] = NULL;
     }
 
-    cap->free_tvar_wait_queues = END_STM_WAIT_QUEUE;
+    cap->free_tvar_watch_queues = END_STM_WATCH_QUEUE;
+    cap->free_invariant_check_queues = END_INVARIANT_CHECK_QUEUE;
     cap->free_trec_chunks = END_STM_CHUNK_LIST;
     cap->free_trec_headers = NO_TREC;
     cap->transaction_tokens = 0;
@@ -646,7 +647,13 @@ shutdownCapability (Capability *cap, Task *task)
 
     task->cap = cap;
 
-    for (i = 0; i < 50; i++) {
+    // Loop indefinitely until all the workers have exited and there
+    // are no Haskell threads left.  We used to bail out after 50
+    // iterations of this loop, but that occasionally left a worker
+    // running which caused problems later (the closeMutex() below
+    // isn't safe, for one thing).
+
+    for (i = 0; /* i < 50 */; i++) {
 	debugTrace(DEBUG_sched, 
 		   "shutting down capability %d, attempt %d", cap->no, i);
 	ACQUIRE_LOCK(&cap->lock);
@@ -657,6 +664,30 @@ shutdownCapability (Capability *cap, Task *task)
 	    continue;
 	}
 	cap->running_task = task;
+
+        if (cap->spare_workers) {
+            // Look for workers that have died without removing
+            // themselves from the list; this could happen if the OS
+            // summarily killed the thread, for example.  This
+            // actually happens on Windows when the system is
+            // terminating the program, and the RTS is running in a
+            // DLL.
+            Task *t, *prev;
+            prev = NULL;
+            for (t = cap->spare_workers; t != NULL; t = t->next) {
+                if (!osThreadIsAlive(t->id)) {
+                    debugTrace(DEBUG_sched, 
+                               "worker thread %p has died unexpectedly", (void *)t->id);
+                        if (!prev) {
+                            cap->spare_workers = t->next;
+                        } else {
+                            prev->next = t->next;
+                        }
+                        prev = t;
+                }
+            }
+        }
+
 	if (!emptyRunQueue(cap) || cap->spare_workers) {
 	    debugTrace(DEBUG_sched, 
 		       "runnable threads or workers still alive, yielding");
@@ -666,14 +697,17 @@ shutdownCapability (Capability *cap, Task *task)
 	    continue;
 	}
 	debugTrace(DEBUG_sched, "capability %d is stopped.", cap->no);
+    freeCapability(cap);
 	RELEASE_LOCK(&cap->lock);
 	break;
     }
     // we now have the Capability, its run queue and spare workers
     // list are both empty.
 
-    // We end up here only in THREADED_RTS
-    closeMutex(&cap->lock);
+    // ToDo: we can't drop this mutex, because there might still be
+    // threads performing foreign calls that will eventually try to 
+    // return via resumeThread() and attempt to grab cap->lock.
+    // closeMutex(&cap->lock);
 }
 
 /* ----------------------------------------------------------------------------
@@ -701,4 +735,11 @@ tryGrabCapability (Capability *cap, Task *task)
 
 #endif /* THREADED_RTS */
 
+void
+freeCapability (Capability *cap) {
+    stgFree(cap->mut_lists);
+#if defined(THREADED_RTS) || defined(PARALLEL_HASKELL)
+    freeSparkPool(&cap->r.rSparks);
+#endif
+}