#include "Capability.h"
#include "Stats.h"
#include "RtsFlags.h"
+#include "Storage.h"
#include "Schedule.h"
#include "Hash.h"
#include "Trace.h"
Task *all_tasks = NULL;
static Task *task_free_list = NULL; // singly-linked
static nat taskCount;
-#define DEFAULT_MAX_WORKERS 64
-static nat maxWorkers; // we won't create more workers than this
static nat tasksRunning;
static nat workerCount;
taskCount = 0;
workerCount = 0;
tasksRunning = 0;
-#if defined(THREADED_RTS)
- maxWorkers = DEFAULT_MAX_WORKERS * RtsFlags.ParFlags.nNodes;
-#else
- maxWorkers = DEFAULT_MAX_WORKERS;
-#endif
initialized = 1;
#if defined(THREADED_RTS)
newThreadLocalKey(¤tTaskKey);
debugTrace(DEBUG_sched,
"stopping task manager, %d tasks still running",
tasksRunning);
+ /* nothing to do */
+}
+
+
+void
+freeTaskManager (void)
+{
+ Task *task, *next;
+
+ debugTrace(DEBUG_sched, "freeing task manager");
+
+ ACQUIRE_LOCK(&sched_mutex);
+ for (task = all_tasks; task != NULL; task = next) {
+ next = task->all_link;
+ if (task->stopped) {
+ // We only free resources if the Task is not in use. A
+ // Task may still be in use if we have a Haskell thread in
+ // a foreign call while we are attempting to shut down the
+ // RTS (see conc059).
+#if defined(THREADED_RTS)
+ closeCondition(&task->cond);
+ closeMutex(&task->lock);
+#endif
+ stgFree(task);
+ }
+ }
+ all_tasks = NULL;
+ task_free_list = NULL;
+#if defined(THREADED_RTS)
+ freeThreadLocalKey(¤tTaskKey);
+#endif
+ RELEASE_LOCK(&sched_mutex);
}
{
ASSERT_LOCK_HELD(&sched_mutex);
if (!task->stopped) {
- debugTrace(DEBUG_sched, "discarding task %ld", TASK_ID(task));
+ debugTrace(DEBUG_sched, "discarding task %ld", (long)TASK_ID(task));
task->cap = NULL;
task->tso = NULL;
task->stopped = rtsTrue;
ASSERT(myTask() == task);
#endif
+ task->cap = NULL;
taskTimeStamp(task);
task->stopped = rtsTrue;
tasksRunning--;
+
+ ACQUIRE_LOCK(&sched_mutex);
+ task->next = task_free_list;
+ task_free_list = task;
+ RELEASE_LOCK(&sched_mutex);
}
void
OSThreadId tid;
Task *task;
- if (workerCount >= maxWorkers) {
- barf("too many workers; runaway worker creation?");
- }
workerCount++;
// A worker always gets a fresh Task structure.
r = createOSThread(&tid, (OSThreadProc *)taskStart, task);
if (r != 0) {
- barf("startTask: Can't create new task");
+ sysErrorBelch("failed to create OS thread");
+ stg_exit(EXIT_FAILURE);
}
debugTrace(DEBUG_sched, "new worker task (taskCount: %d)", taskCount);
debugBelch("on capability %d, ", task->cap->no);
}
if (task->tso) {
- debugBelch("bound to thread %d", task->tso->id);
+ debugBelch("bound to thread %lu", (unsigned long)task->tso->id);
} else {
debugBelch("worker");
}