static gint
get_operations_for_jobs (MonoMList *list)
{
MonoMList *current;
gint operations = 0;
for (current = list; current; current = mono_mlist_next (current))
operations |= ((MonoIOSelectorJob*) mono_mlist_get_data (current))->operation;
return operations;
}
static int
get_events_from_list (MonoMList *list)
{
MonoSocketAsyncResult *state;
int events = 0;
while (list && (state = (MonoSocketAsyncResult *)mono_mlist_get_data (list))) {
events |= get_event_from_state (state);
list = mono_mlist_next (list);
}
return events;
}
static gboolean
remove_sockstate_for_domain (gpointer key, gpointer value, gpointer user_data)
{
MonoMList *list = value;
gboolean remove = FALSE;
while (list) {
MonoObject *data = mono_mlist_get_data (list);
if (mono_object_domain (data) == user_data) {
MonoClass *class = mono_object_get_class (data);
remove = TRUE;
mono_mlist_set_data (list, NULL);
}
list = mono_mlist_next (list);
}
void
mono_gc_finalize_threadpool_threads (void)
{
while (threads_to_finalize) {
MonoInternalThread *thread = (MonoInternalThread*) mono_mlist_get_data (threads_to_finalize);
/* Force finalization of the thread. */
thread->threadpool_thread = FALSE;
mono_object_register_finalizer ((MonoObject*)thread);
mono_gc_run_finalize (thread, NULL);
threads_to_finalize = mono_mlist_next (threads_to_finalize);
}
}
static gboolean
remove_sockstate_for_domain (gpointer key, gpointer value, gpointer user_data)
{
MonoMList *list = value;
gboolean remove = FALSE;
while (list) {
MonoObject *data = mono_mlist_get_data (list);
if (mono_object_domain (data) == user_data) {
remove = TRUE;
mono_mlist_set_data (list, NULL);
}
list = mono_mlist_next (list);
}
//FIXME is there some sort of additional unregistration we need to perform here?
return remove;
}
static MonoIOSelectorJob*
get_job_for_event (MonoMList **list, gint32 event)
{
MonoMList *current;
g_assert (list);
for (current = *list; current; current = mono_mlist_next (current)) {
MonoIOSelectorJob *job = (MonoIOSelectorJob*) mono_mlist_get_data (current);
if (job->operation == event) {
*list = mono_mlist_remove_item (*list, current);
return job;
}
}
return NULL;
}
static void
threadpool_clear_queue (ThreadPool *tp, MonoDomain *domain)
{
MonoObject *obj;
MonoMList *other;
other = NULL;
while (mono_cq_dequeue (tp->queue, &obj)) {
if (obj == NULL)
continue;
if (obj->vtable->domain != domain)
other = mono_mlist_prepend (other, obj);
threadpool_jobs_dec (obj);
}
while (other) {
threadpool_append_job (tp, (MonoObject *) mono_mlist_get_data (other));
other = mono_mlist_next (other);
}
}
static void
threadpool_clear_queue (ThreadPool *tp, MonoDomain *domain)
{
MonoObject *obj;
MonoMList *other;
int domain_count;
other = NULL;
domain_count = 0;
while (mono_cq_dequeue (tp->queue, &obj)) {
if (obj != NULL && obj->vtable->domain == domain) {
domain_count++;
threadpool_jobs_dec (obj);
} else if (obj != NULL) {
other = mono_mlist_prepend (other, obj);
}
}
while (other) {
threadpool_append_job (tp, (MonoObject *) mono_mlist_get_data (other));
other = mono_mlist_next (other);
}
}
static MonoMList *
process_io_event (MonoMList *list, int event)
{
MonoSocketAsyncResult *state;
MonoMList *oldlist;
oldlist = list;
state = NULL;
while (list) {
state = (MonoSocketAsyncResult *) mono_mlist_get_data (list);
if (get_event_from_state (state) == event)
break;
list = mono_mlist_next (list);
}
if (list != NULL) {
oldlist = mono_mlist_remove_item (oldlist, list);
EPOLL_DEBUG ("Dispatching event %d on socket %p", event, state->handle);
threadpool_append_job (&async_io_tp, (MonoObject *) state);
}
return oldlist;
}
static void
selector_thread (gpointer data)
{
MonoGHashTable *states;
io_selector_running = TRUE;
if (mono_runtime_is_shutting_down ()) {
io_selector_running = FALSE;
return;
}
states = mono_g_hash_table_new_type (g_direct_hash, g_direct_equal, MONO_HASH_VALUE_GC, MONO_ROOT_SOURCE_THREAD_POOL, "i/o thread pool states table");
for (;;) {
gint i, j;
gint res;
mono_mutex_lock (&threadpool_io->updates_lock);
for (i = 0; i < threadpool_io->updates_size; ++i) {
ThreadPoolIOUpdate *update = &threadpool_io->updates [i];
switch (update->type) {
case UPDATE_EMPTY:
break;
case UPDATE_ADD: {
gint fd;
gint operations;
gpointer k;
gboolean exists;
MonoMList *list = NULL;
MonoIOSelectorJob *job;
fd = update->data.add.fd;
g_assert (fd >= 0);
job = update->data.add.job;
g_assert (job);
exists = mono_g_hash_table_lookup_extended (states, GINT_TO_POINTER (fd), &k, (gpointer*) &list);
list = mono_mlist_append (list, (MonoObject*) job);
mono_g_hash_table_replace (states, GINT_TO_POINTER (fd), list);
operations = get_operations_for_jobs (list);
mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_THREADPOOL, "io threadpool: %3s fd %3d, operations = %2s | %2s | %2s",
exists ? "mod" : "add", fd, (operations & EVENT_IN) ? "RD" : "..", (operations & EVENT_OUT) ? "WR" : "..");
threadpool_io->backend.register_fd (fd, operations, !exists);
break;
}
case UPDATE_REMOVE_SOCKET: {
gint fd;
gpointer k;
MonoMList *list = NULL;
fd = update->data.remove_socket.fd;
g_assert (fd >= 0);
if (mono_g_hash_table_lookup_extended (states, GINT_TO_POINTER (fd), &k, (gpointer*) &list)) {
mono_g_hash_table_remove (states, GINT_TO_POINTER (fd));
for (j = i + 1; j < threadpool_io->updates_size; ++j) {
ThreadPoolIOUpdate *update = &threadpool_io->updates [j];
if (update->type == UPDATE_ADD && update->data.add.fd == fd)
memset (update, 0, sizeof (ThreadPoolIOUpdate));
}
for (; list; list = mono_mlist_remove_item (list, list))
mono_threadpool_ms_enqueue_work_item (mono_object_domain (mono_mlist_get_data (list)), mono_mlist_get_data (list));
mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_THREADPOOL, "io threadpool: del fd %3d", fd);
threadpool_io->backend.remove_fd (fd);
}
break;
}
case UPDATE_REMOVE_DOMAIN: {
MonoDomain *domain;
domain = update->data.remove_domain.domain;
g_assert (domain);
FilterSockaresForDomainData user_data = { .domain = domain, .states = states };
mono_g_hash_table_foreach (states, filter_jobs_for_domain, &user_data);
for (j = i + 1; j < threadpool_io->updates_size; ++j) {
ThreadPoolIOUpdate *update = &threadpool_io->updates [j];
if (update->type == UPDATE_ADD && mono_object_domain (update->data.add.job) == domain)
memset (update, 0, sizeof (ThreadPoolIOUpdate));
}
break;
}
default:
g_assert_not_reached ();
}
}
mono_cond_broadcast (&threadpool_io->updates_cond);
if (threadpool_io->updates_size > 0) {
threadpool_io->updates_size = 0;
memset (&threadpool_io->updates, 0, UPDATES_CAPACITY * sizeof (ThreadPoolIOUpdate));
}
mono_mutex_unlock (&threadpool_io->updates_lock);
mono_trace (G_LOG_LEVEL_DEBUG, MONO_TRACE_IO_THREADPOOL, "io threadpool: wai");
res = threadpool_io->backend.event_wait (wait_callback, states);
if (res == -1 || mono_runtime_is_shutting_down ())
break;
}
mono_g_hash_table_destroy (states);
io_selector_running = FALSE;
}
