static void
file_mmap_init (void)
{
retry:
switch (mmap_init_state) {
case 0:
if (InterlockedCompareExchange (&mmap_init_state, 1, 0) != 0)
goto retry;
named_regions = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, NULL);
mono_coop_mutex_init (&named_regions_mutex);
mono_atomic_store_release (&mmap_init_state, 2);
break;
case 1:
do {
mono_thread_info_sleep (1, NULL); /* Been init'd by other threads, this is very rare. */
} while (mmap_init_state != 2);
break;
case 2:
break;
default:
g_error ("Invalid init state %d", mmap_init_state);
}
}
static void
initialize (void)
{
g_assert (!threadpool_io);
threadpool_io = g_new0 (ThreadPoolIO, 1);
g_assert (threadpool_io);
mono_coop_mutex_init (&threadpool_io->updates_lock);
mono_coop_cond_init (&threadpool_io->updates_cond);
mono_gc_register_root ((char *)&threadpool_io->updates [0], sizeof (threadpool_io->updates), MONO_GC_DESCRIPTOR_NULL, MONO_ROOT_SOURCE_THREAD_POOL, "i/o thread pool updates list");
threadpool_io->updates_size = 0;
threadpool_io->backend = backend_poll;
if (g_getenv ("MONO_ENABLE_AIO") != NULL) {
#if defined(HAVE_EPOLL)
threadpool_io->backend = backend_epoll;
#elif defined(HAVE_KQUEUE)
threadpool_io->backend = backend_kqueue;
#endif
}
wakeup_pipes_init ();
if (!threadpool_io->backend.init (threadpool_io->wakeup_pipes [0]))
g_error ("initialize: backend->init () failed");
MonoError error;
if (!mono_thread_create_internal (mono_get_root_domain (), selector_thread, NULL, TRUE, SMALL_STACK, &error))
g_error ("initialize: mono_thread_create_internal () failed due to %s", mono_error_get_message (&error));
}
static void
sleep_initialize (void)
{
mono_coop_mutex_init (&sleep_mutex);
mono_coop_cond_init (&sleep_cond);
}
void
mono_threadpool_worker_init (MonoThreadPoolWorkerCallback callback)
{
ThreadPoolHillClimbing *hc;
const char *threads_per_cpu_env;
gint threads_per_cpu;
gint threads_count;
mono_refcount_init (&worker, destroy);
worker.callback = callback;
mono_coop_mutex_init (&worker.parked_threads_lock);
worker.parked_threads_count = 0;
mono_coop_cond_init (&worker.parked_threads_cond);
worker.worker_creation_current_second = -1;
mono_coop_mutex_init (&worker.worker_creation_lock);
worker.heuristic_adjustment_interval = 10;
mono_coop_mutex_init (&worker.heuristic_lock);
mono_rand_open ();
hc = &worker.heuristic_hill_climbing;
hc->wave_period = HILL_CLIMBING_WAVE_PERIOD;
hc->max_thread_wave_magnitude = HILL_CLIMBING_MAX_WAVE_MAGNITUDE;
hc->thread_magnitude_multiplier = (gdouble) HILL_CLIMBING_WAVE_MAGNITUDE_MULTIPLIER;
hc->samples_to_measure = hc->wave_period * HILL_CLIMBING_WAVE_HISTORY_SIZE;
hc->target_throughput_ratio = (gdouble) HILL_CLIMBING_BIAS;
hc->target_signal_to_noise_ratio = (gdouble) HILL_CLIMBING_TARGET_SIGNAL_TO_NOISE_RATIO;
hc->max_change_per_second = (gdouble) HILL_CLIMBING_MAX_CHANGE_PER_SECOND;
hc->max_change_per_sample = (gdouble) HILL_CLIMBING_MAX_CHANGE_PER_SAMPLE;
hc->sample_interval_low = HILL_CLIMBING_SAMPLE_INTERVAL_LOW;
hc->sample_interval_high = HILL_CLIMBING_SAMPLE_INTERVAL_HIGH;
hc->throughput_error_smoothing_factor = (gdouble) HILL_CLIMBING_ERROR_SMOOTHING_FACTOR;
hc->gain_exponent = (gdouble) HILL_CLIMBING_GAIN_EXPONENT;
hc->max_sample_error = (gdouble) HILL_CLIMBING_MAX_SAMPLE_ERROR_PERCENT;
hc->current_control_setting = 0;
hc->total_samples = 0;
hc->last_thread_count = 0;
hc->average_throughput_noise = 0;
hc->elapsed_since_last_change = 0;
hc->accumulated_completion_count = 0;
hc->accumulated_sample_duration = 0;
hc->samples = g_new0 (gdouble, hc->samples_to_measure);
hc->thread_counts = g_new0 (gdouble, hc->samples_to_measure);
hc->random_interval_generator = rand_create ();
hc->current_sample_interval = rand_next (&hc->random_interval_generator, hc->sample_interval_low, hc->sample_interval_high);
if (!(threads_per_cpu_env = g_getenv ("MONO_THREADS_PER_CPU")))
threads_per_cpu = 1;
else
threads_per_cpu = CLAMP (atoi (threads_per_cpu_env), 1, 50);
threads_count = mono_cpu_count () * threads_per_cpu;
worker.limit_worker_min = threads_count;
#if defined (PLATFORM_ANDROID) || defined (HOST_IOS)
worker.limit_worker_max = CLAMP (threads_count * 100, MIN (threads_count, 200), MAX (threads_count, 200));
#else
worker.limit_worker_max = threads_count * 100;
#endif
worker.counters._.max_working = worker.limit_worker_min;
worker.cpu_usage_state = g_new0 (MonoCpuUsageState, 1);
worker.suspended = FALSE;
worker.monitor_status = MONITOR_STATUS_NOT_RUNNING;
}
void
mono_w32handle_namespace_init (void)
{
mono_coop_mutex_init (&lock);
}