static void*
register_thread (MonoThreadInfo *info, gpointer baseptr)
{
int small_id = mono_thread_info_register_small_id ();
gboolean result;
mono_thread_info_set_tid (info, mono_native_thread_id_get ());
info->small_id = small_id;
MONO_SEM_INIT (&info->suspend_semaphore, 1);
MONO_SEM_INIT (&info->resume_semaphore, 0);
MONO_SEM_INIT (&info->finish_resume_semaphore, 0);
/*set TLS early so SMR works */
mono_native_tls_set_value (thread_info_key, info);
THREADS_DEBUG ("registering info %p tid %p small id %x\n", info, mono_thread_info_get_tid (info), info->small_id);
if (threads_callbacks.thread_register) {
if (threads_callbacks.thread_register (info, baseptr) == NULL) {
g_warning ("thread registation failed\n");
g_free (info);
return NULL;
}
}
mono_threads_platform_register (info);
info->thread_state = STATE_RUNNING;
mono_thread_info_suspend_lock ();
/*If this fail it means a given thread has been registered twice, which doesn't make sense. */
result = mono_thread_info_insert (info);
g_assert (result);
mono_thread_info_suspend_unlock ();
return info;
}
static void*
worker (void *arg)
{
thread_data_t *thread_data = (thread_data_t *)arg;
MonoThreadHazardPointers *hp;
int skip = thread_data->skip;
int i, j;
gboolean result;
mono_thread_info_register_small_id ();
hp = mono_hazard_pointer_get ();
i = 0;
for (j = 0; j < NUM_ITERS; ++j) {
switch (nodes [i].state) {
case STATE_BUSY:
mono_thread_hazardous_try_free_some ();
break;
case STATE_OUT:
if (InterlockedCompareExchange (&nodes [i].state, STATE_BUSY, STATE_OUT) == STATE_OUT) {
result = mono_lls_find (&lls, hp, i, HAZARD_FREE_SAFE_CTX);
assert (!result);
mono_hazard_pointer_clear_all (hp, -1);
result = mono_lls_insert (&lls, hp, &nodes [i].node, HAZARD_FREE_SAFE_CTX);
mono_hazard_pointer_clear_all (hp, -1);
assert (nodes [i].state == STATE_BUSY);
nodes [i].state = STATE_IN;
++thread_data->num_adds;
}
break;
case STATE_IN:
if (InterlockedCompareExchange (&nodes [i].state, STATE_BUSY, STATE_IN) == STATE_IN) {
result = mono_lls_find (&lls, hp, i, HAZARD_FREE_SAFE_CTX);
assert (result);
assert (mono_hazard_pointer_get_val (hp, 1) == &nodes [i].node);
mono_hazard_pointer_clear_all (hp, -1);
result = mono_lls_remove (&lls, hp, &nodes [i].node, HAZARD_FREE_SAFE_CTX);
mono_hazard_pointer_clear_all (hp, -1);
++thread_data->num_removes;
}
break;
default:
assert (FALSE);
}
i += skip;
if (i >= N)
i -= N;
}
return NULL;
}
static void*
register_thread (MonoThreadInfo *info, gpointer baseptr)
{
size_t stsize = 0;
guint8 *staddr = NULL;
int small_id = mono_thread_info_register_small_id ();
gboolean result;
mono_thread_info_set_tid (info, mono_native_thread_id_get ());
info->small_id = small_id;
info->handle = g_new0 (MonoThreadHandle, 1);
mono_refcount_init (info->handle, thread_handle_destroy);
mono_os_event_init (&info->handle->event, FALSE);
mono_os_sem_init (&info->resume_semaphore, 0);
/*set TLS early so SMR works */
mono_native_tls_set_value (thread_info_key, info);
THREADS_DEBUG ("registering info %p tid %p small id %x\n", info, mono_thread_info_get_tid (info), info->small_id);
if (threads_callbacks.thread_register) {
if (threads_callbacks.thread_register (info, baseptr) == NULL) {
// g_warning ("thread registation failed\n");
mono_native_tls_set_value (thread_info_key, NULL);
g_free (info);
return NULL;
}
}
mono_thread_info_get_stack_bounds (&staddr, &stsize);
g_assert (staddr);
g_assert (stsize);
info->stack_start_limit = staddr;
info->stack_end = staddr + stsize;
info->stackdata = g_byte_array_new ();
mono_threads_suspend_register (info);
/*
Transition it before taking any locks or publishing itself to reduce the chance
of others witnessing a detached thread.
We can reasonably expect that until this thread gets published, no other thread will
try to manipulate it.
*/
mono_threads_transition_attach (info);
mono_thread_info_suspend_lock ();
/*If this fail it means a given thread has been registered twice, which doesn't make sense. */
result = mono_thread_info_insert (info);
g_assert (result);
mono_thread_info_suspend_unlock ();
return info;
}
static mono_native_thread_return_t
workers_thread_func (void *data_untyped)
{
WorkerData *data = data_untyped;
SgenMajorCollector *major = sgen_get_major_collector ();
mono_thread_info_register_small_id ();
if (major->init_worker_thread)
major->init_worker_thread (data->major_collector_data);
init_private_gray_queue (data);
for (;;) {
gboolean did_work = FALSE;
SGEN_ASSERT (0, sgen_get_current_collection_generation () != GENERATION_NURSERY, "Why are we doing work while there's a nursery collection happening?");
while (workers_state.data.state == STATE_WORKING && workers_dequeue_and_do_job (data)) {
did_work = TRUE;
/* FIXME: maybe distribute the gray queue here? */
}
if (!did_work && (!sgen_gray_object_queue_is_empty (&data->private_gray_queue) || workers_get_work (data))) {
SgenObjectOperations *ops = sgen_concurrent_collection_in_progress ()
? &major->major_concurrent_ops
: &major->major_ops;
ScanCopyContext ctx = { ops->scan_object, NULL, &data->private_gray_queue };
g_assert (!sgen_gray_object_queue_is_empty (&data->private_gray_queue));
while (!sgen_drain_gray_stack (32, ctx)) {
if (workers_state.data.state == STATE_NURSERY_COLLECTION)
workers_wait ();
}
g_assert (sgen_gray_object_queue_is_empty (&data->private_gray_queue));
init_private_gray_queue (data);
did_work = TRUE;
}
if (!did_work)
workers_wait ();
}
/* dummy return to make compilers happy */
return NULL;
}
static mono_native_thread_return_t
workers_thread_func (void *data_untyped)
{
WorkerData *data = data_untyped;
SgenMajorCollector *major = sgen_get_major_collector ();
mono_thread_info_register_small_id ();
if (major->init_worker_thread)
major->init_worker_thread (data->major_collector_data);
init_private_gray_queue (data);
for (;;) {
gboolean did_work = FALSE;
while (workers_dequeue_and_do_job (data)) {
did_work = TRUE;
/* FIXME: maybe distribute the gray queue here? */
}
if (workers_marking && (!sgen_gray_object_queue_is_empty (&data->private_gray_queue) || workers_get_work (data))) {
SgenObjectOperations *ops = sgen_concurrent_collection_in_progress ()
? &major->major_concurrent_ops
: &major->major_ops;
ScanCopyContext ctx = { ops->scan_object, NULL, &data->private_gray_queue };
g_assert (!sgen_gray_object_queue_is_empty (&data->private_gray_queue));
while (!sgen_drain_gray_stack (32, ctx))
workers_gray_queue_share_redirect (&data->private_gray_queue);
g_assert (sgen_gray_object_queue_is_empty (&data->private_gray_queue));
init_private_gray_queue (data);
did_work = TRUE;
}
if (!did_work)
workers_wait ();
}
/* dummy return to make compilers happy */
return NULL;
}
static mono_native_thread_return_t
workers_thread_func (void *data_untyped)
{
WorkerData *data = data_untyped;
mono_thread_info_register_small_id ();
if (sgen_get_major_collector ()->init_worker_thread)
sgen_get_major_collector ()->init_worker_thread (data->major_collector_data);
sgen_gray_object_queue_init_with_alloc_prepare (&data->private_gray_queue,
workers_gray_queue_share_redirect, data);
for (;;) {
gboolean did_work = FALSE;
while (workers_dequeue_and_do_job (data)) {
did_work = TRUE;
/* FIXME: maybe distribute the gray queue here? */
}
if (workers_marking && (!sgen_gray_object_queue_is_empty (&data->private_gray_queue) || workers_get_work (data))) {
g_assert (!sgen_gray_object_queue_is_empty (&data->private_gray_queue));
while (!sgen_drain_gray_stack (&data->private_gray_queue, 32))
workers_gray_queue_share_redirect (&data->private_gray_queue);
g_assert (sgen_gray_object_queue_is_empty (&data->private_gray_queue));
sgen_gray_object_queue_init (&data->private_gray_queue);
did_work = TRUE;
}
if (!did_work)
workers_wait ();
}
/* dummy return to make compilers happy */
return NULL;
}
