gboolean
mono_thread_info_resume (MonoNativeThreadId tid)
{
gboolean result; /* don't initialize it so the compiler can catch unitilized paths. */
MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
MonoThreadInfo *info = mono_thread_info_lookup (tid); /*info on HP1*/
if (!info) {
result = FALSE;
goto cleanup;
}
result = mono_thread_info_core_resume (info);
cleanup:
mono_hazard_pointer_clear (hp, 1);
return result;
}
void
mono_runtime_shutdown_stat_profiler (void)
{
mono_atomic_store_i32 (&sampling_thread_running, 0);
mono_profiler_sampling_thread_post ();
#ifndef HOST_DARWIN
/*
* There is a slight problem when we're using CLOCK_PROCESS_CPUTIME_ID: If
* we're shutting down and there's largely no activity in the process other
* than waiting for the sampler thread to shut down, it can take upwards of
* 20 seconds (depending on a lot of factors) for us to shut down because
* the sleep progresses very slowly as a result of the low CPU activity.
*
* We fix this by repeatedly sending the profiler signal to the sampler
* thread in order to interrupt the sleep. clock_sleep_ns_abs () will check
* sampling_thread_running upon an interrupt and return immediately if it's
* zero. profiler_signal_handler () has a special case to ignore the signal
* for the sampler thread.
*/
MonoThreadInfo *info;
// Did it shut down already?
if ((info = mono_thread_info_lookup (sampling_thread))) {
while (!mono_atomic_load_i32 (&sampling_thread_exiting)) {
mono_threads_pthread_kill (info, profiler_signal);
mono_thread_info_usleep (10 * 1000 /* 10ms */);
}
// Make sure info can be freed.
mono_hazard_pointer_clear (mono_hazard_pointer_get (), 1);
}
#endif
mono_os_event_wait_one (&sampling_thread_exited, MONO_INFINITE_WAIT, FALSE);
mono_os_event_destroy (&sampling_thread_exited);
/*
* We can't safely remove the signal handler because we have no guarantee
* that all pending signals have been delivered at this point. This should
* not really be a problem anyway.
*/
//remove_signal_handler (profiler_signal);
}
void
mono_thread_info_safe_suspend_and_run (MonoNativeThreadId id, gboolean interrupt_kernel, MonoSuspendThreadCallback callback, gpointer user_data)
{
int result;
MonoThreadInfo *info = NULL;
MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
THREADS_SUSPEND_DEBUG ("SUSPENDING tid %p\n", (void*)id);
/*FIXME: unify this with self-suspend*/
g_assert (id != mono_native_thread_id_get ());
/* This can block during stw */
mono_thread_info_suspend_lock ();
mono_threads_begin_global_suspend ();
info = suspend_sync_nolock (id, interrupt_kernel);
if (!info)
goto done;
switch (result = callback (info, user_data)) {
case MonoResumeThread:
mono_hazard_pointer_set (hp, 1, info);
mono_thread_info_core_resume (info);
mono_threads_wait_pending_operations ();
break;
case KeepSuspended:
g_assert (!mono_threads_is_coop_enabled ());
break;
default:
g_error ("Invalid suspend_and_run callback return value %d", result);
}
done:
mono_hazard_pointer_clear (hp, 1);
mono_threads_end_global_suspend ();
mono_thread_info_suspend_unlock ();
}
MonoLockFreeQueueNode*
mono_lock_free_queue_dequeue (MonoLockFreeQueue *q)
{
MonoThreadHazardPointers *hp = mono_hazard_pointer_get ();
MonoLockFreeQueueNode *head;
retry:
for (;;) {
MonoLockFreeQueueNode *tail, *next;
head = (MonoLockFreeQueueNode *) get_hazardous_pointer ((gpointer volatile*)&q->head, hp, 0);
tail = (MonoLockFreeQueueNode*)q->tail;
mono_memory_read_barrier ();
next = head->next;
mono_memory_read_barrier ();
/* Are head, tail and next consistent? */
if (head == q->head) {
g_assert (next != INVALID_NEXT && next != FREE_NEXT);
g_assert (next != head);
/* Is queue empty or tail behind? */
if (head == tail) {
if (next == END_MARKER) {
/* Queue is empty */
mono_hazard_pointer_clear (hp, 0);
/*
* We only continue if we
* reenqueue the dummy
* ourselves, so as not to
* wait for threads that might
* not actually run.
*/
if (!is_dummy (q, head) && try_reenqueue_dummy (q))
continue;
return NULL;
}
/* Try to advance tail */
InterlockedCompareExchangePointer ((gpointer volatile*)&q->tail, next, tail);
} else {
g_assert (next != END_MARKER);
/* Try to dequeue head */
if (InterlockedCompareExchangePointer ((gpointer volatile*)&q->head, next, head) == head)
break;
}
}
mono_memory_write_barrier ();
mono_hazard_pointer_clear (hp, 0);
}
/*
* The head is dequeued now, so we know it's this thread's
* responsibility to free it - no other thread can.
*/
mono_memory_write_barrier ();
mono_hazard_pointer_clear (hp, 0);
g_assert (head->next);
/*
* Setting next here isn't necessary for correctness, but we
* do it to make sure that we catch dereferencing next in a
* node that's not in the queue anymore.
*/
head->next = INVALID_NEXT;
#if QUEUE_DEBUG
g_assert (head->in_queue);
head->in_queue = FALSE;
mono_memory_write_barrier ();
#endif
if (is_dummy (q, head)) {
g_assert (q->has_dummy);
q->has_dummy = 0;
mono_memory_write_barrier ();
mono_thread_hazardous_free_or_queue (head, free_dummy, FALSE, TRUE);
if (try_reenqueue_dummy (q))
goto retry;
return NULL;
}
/* The caller must hazardously free the node. */
return head;
}
