void
interruptWorkerTask (Task *task)
{
ASSERT(osThreadId() != task->id); // seppuku not allowed
ASSERT(task->incall->suspended_tso); // use this only for FFI calls
interruptOSThread(task->id);
debugTrace(DEBUG_sched, "interrupted worker task %#" FMT_HexWord64,
serialisableTaskId(task));
}
void traceTaskDelete_ (Task *task)
{
#ifdef DEBUG
if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
/* We currently don't do debug tracing of tasks but we must
test for TRACE_STDERR because of the !eventlog_enabled case. */
} else
#endif
{
EventTaskId taskid = serialisableTaskId(task);
postTaskDeleteEvent(taskid);
}
}
void traceTaskMigrate_ (Task *task,
Capability *cap,
Capability *new_cap)
{
#ifdef DEBUG
if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
/* We currently don't do debug tracing of tasks but we must
test for TRACE_STDERR because of the !eventlog_enabled case. */
} else
#endif
{
EventTaskId taskid = serialisableTaskId(task);
postTaskMigrateEvent(taskid, cap->no, new_cap->no);
}
}
void traceTaskCreate_ (Task *task,
Capability *cap)
{
#if defined(DEBUG)
if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
/* We currently don't do debug tracing of tasks but we must
test for TRACE_STDERR because of the !eventlog_enabled case. */
} else
#endif
{
EventTaskId taskid = serialisableTaskId(task);
EventKernelThreadId tid = kernelThreadId();
postTaskCreateEvent(taskid, cap->no, tid);
}
}
void
printAllTasks(void)
{
Task *task;
for (task = all_tasks; task != NULL; task = task->all_next) {
debugBelch("task %#" FMT_HexWord64 " is %s, ", serialisableTaskId(task),
task->stopped ? "stopped" : "alive");
if (!task->stopped) {
if (task->cap) {
debugBelch("on capability %d, ", task->cap->no);
}
if (task->incall->tso) {
debugBelch("bound to thread %lu",
(unsigned long)task->incall->tso->id);
} else {
debugBelch("worker");
}
}
debugBelch("\n");
}
}
* modifying task->cap, to synchronise with the waking up Task.
* Additionally, the migrater should own the Capability (when
* migrating the run queue), or cap->lock (when migrating
* returning_workers).
*
* ------------------------------------------------------------------------- */
#if defined(THREADED_RTS)
STATIC_INLINE void
giveCapabilityToTask (Capability *cap USED_IF_DEBUG, Task *task)
{
ASSERT_LOCK_HELD(&cap->lock);
ASSERT(task->cap == cap);
debugTrace(DEBUG_sched, "passing capability %d to %s %#" FMT_HexWord64,
cap->no, task->incall->tso ? "bound task" : "worker",
serialisableTaskId(task));
ACQUIRE_LOCK(&task->lock);
if (task->wakeup == rtsFalse) {
task->wakeup = rtsTrue;
// the wakeup flag is needed because signalCondition() doesn't
// flag the condition if the thread is already runniing, but we want
// it to be sticky.
signalCondition(&task->cond);
}
RELEASE_LOCK(&task->lock);
}
#endif
/* ----------------------------------------------------------------------------
* Function: releaseCapability(Capability*)
*
