/*
* wapi_init:
*
* Initialize the io-layer.
*/
void
mono_w32handle_init (void)
{
static gboolean initialized = FALSE;
if (initialized)
return;
g_assert ((sizeof (handle_ops) / sizeof (handle_ops[0]))
== MONO_W32HANDLE_COUNT);
/* This is needed by the code in mono_w32handle_new_internal */
mono_w32handle_fd_reserve = (eg_getdtablesize () + (HANDLE_PER_SLOT - 1)) & ~(HANDLE_PER_SLOT - 1);
do {
/*
* The entries in private_handles reserved for fds are allocated lazily to
* save memory.
*/
private_handles_count += HANDLE_PER_SLOT;
private_handles_slots_count ++;
} while(mono_w32handle_fd_reserve > private_handles_count);
mono_os_mutex_init (&scan_mutex);
mono_os_cond_init (&global_signal_cond);
mono_os_mutex_init (&global_signal_mutex);
initialized = TRUE;
}
static int
parallel_writer_single_reader (void)
{
pthread_t a,b,c;
int i, j, res = 0;
mono_os_mutex_init (&global_mutex);
hash = mono_conc_hashtable_new (NULL, NULL);
pthread_create (&a, NULL, pw_sr_thread, GINT_TO_POINTER (1));
pthread_create (&b, NULL, pw_sr_thread, GINT_TO_POINTER (2));
pthread_create (&c, NULL, pw_sr_thread, GINT_TO_POINTER (3));
pthread_join (a, NULL);
pthread_join (b, NULL);
pthread_join (c, NULL);
for (i = 0; i < 1000; ++i) {
for (j = 1; j < 4; ++j) {
if (mono_conc_hashtable_lookup (hash, GINT_TO_POINTER (j * 1000 + i)) != GINT_TO_POINTER (i + 1)) {
res = j + 1;
goto done;
}
}
}
done:
mono_conc_hashtable_destroy (hash);
mono_os_mutex_destroy (&global_mutex);
if (res)
printf ("PAR_WRITER_SINGLE_READER TEST FAILED %d\n", res);
return res;
}
static void
noshm_semaphores_init (void)
{
int i;
for (i = 0; i < _WAPI_SHARED_SEM_COUNT; i++)
mono_os_mutex_init (&noshm_sems [i]);
}
void
mono_counters_init (void)
{
if (initialized)
return;
mono_os_mutex_init (&counters_mutex);
initialize_system_counters ();
initialized = TRUE;
}
static int
parallel_writer_parallel_reader (void)
{
pthread_t wa, wb, wc, ra, rb, rc;
gpointer a, b, c;
int res = 0, i;
srand(time(NULL));
mono_os_mutex_init (&global_mutex);
hash = mono_conc_hashtable_new (NULL, NULL);
for (i = 0; i < 2; i++) {
running = 1;
pthread_create (&ra, NULL, pw_pr_r_thread, NULL);
pthread_create (&rb, NULL, pw_pr_r_thread, NULL);
pthread_create (&rc, NULL, pw_pr_r_thread, NULL);
switch (i) {
case 0:
pthread_create (&wa, NULL, pw_pr_w_add_thread, GINT_TO_POINTER (0));
pthread_create (&wb, NULL, pw_pr_w_add_thread, GINT_TO_POINTER (1));
pthread_create (&wc, NULL, pw_pr_w_add_thread, GINT_TO_POINTER (2));
break;
case 1:
pthread_create (&wa, NULL, pw_pr_w_del_thread, GINT_TO_POINTER (0));
pthread_create (&wb, NULL, pw_pr_w_del_thread, GINT_TO_POINTER (1));
pthread_create (&wc, NULL, pw_pr_w_del_thread, GINT_TO_POINTER (2));
break;
}
pthread_join (wa, NULL);
pthread_join (wb, NULL);
pthread_join (wc, NULL);
running = 0;
pthread_join (ra, &a);
pthread_join (rb, &b);
pthread_join (rc, &c);
res += GPOINTER_TO_INT (a) + GPOINTER_TO_INT (b) + GPOINTER_TO_INT (c);
}
if (res)
printf ("PAR_WRITER_PAR_READER TEST FAILED %d %d %d\n", GPOINTER_TO_INT (a), GPOINTER_TO_INT (b), GPOINTER_TO_INT (c));
mono_conc_hashtable_destroy (hash);
mono_os_mutex_destroy (&global_mutex);
return res;
}
static void mono_w32handle_init_handle (MonoW32HandleBase *handle,
MonoW32HandleType type, gpointer handle_specific)
{
g_assert (handle->ref == 0);
handle->type = type;
handle->signalled = FALSE;
handle->ref = 1;
mono_os_cond_init (&handle->signal_cond);
mono_os_mutex_init (&handle->signal_mutex);
if (handle_specific)
handle->specific = g_memdup (handle_specific, mono_w32handle_ops_typesize (type));
}
void mono_profiler_startup (const char *desc)
{
MonoProfiler *prof = g_new0 (MonoProfiler, 1);
mono_os_mutex_init (&mismatched_files_section);
prof->mismatched_files_hash = g_hash_table_new (mismatched_files_guint32_hash, mismatched_files_guint32_equal);
prof->saved_strings_hash = g_hash_table_new (NULL, NULL);
prof->string_locations_hash = g_hash_table_new (mismatched_files_guint32_hash, mismatched_files_guint32_equal);
mono_profiler_install (prof, profiler_shutdown);
mono_profiler_install_runtime_initialized (runtime_initialized_cb);
mono_profiler_install_iomap (mono_portability_iomap_event);
mono_profiler_install_allocation (mono_portability_remember_alloc);
mono_profiler_set_events ((MonoProfileFlags)(MONO_PROFILE_ALLOCATIONS | MONO_PROFILE_IOMAP_EVENTS));
}
void
sgen_gray_object_queue_init (SgenGrayQueue *queue, GrayQueueEnqueueCheckFunc enqueue_check_func, gboolean reuse_free_list)
{
memset (queue, 0, sizeof (SgenGrayQueue));
#ifdef SGEN_CHECK_GRAY_OBJECT_ENQUEUE
queue->enqueue_check_func = enqueue_check_func;
#endif
mono_os_mutex_init (&queue->steal_mutex);
if (reuse_free_list) {
queue->free_list = last_gray_queue_free_list;
last_gray_queue_free_list = NULL;
}
}
static int
single_writer_single_reader (void)
{
mono_mutex_t mutex;
MonoConcurrentHashTable *h;
int res = 0;
mono_os_mutex_init (&mutex);
h = mono_conc_hashtable_new (NULL, NULL);
mono_os_mutex_lock (&mutex);
mono_conc_hashtable_insert (h, GUINT_TO_POINTER (10), GUINT_TO_POINTER (20));
mono_os_mutex_unlock (&mutex);
mono_os_mutex_lock (&mutex);
mono_conc_hashtable_insert (h, GUINT_TO_POINTER (30), GUINT_TO_POINTER (40));
mono_os_mutex_unlock (&mutex);
mono_os_mutex_lock (&mutex);
mono_conc_hashtable_insert (h, GUINT_TO_POINTER (50), GUINT_TO_POINTER (60));
mono_os_mutex_unlock (&mutex);
mono_os_mutex_lock (&mutex);
mono_conc_hashtable_insert (h, GUINT_TO_POINTER (2), GUINT_TO_POINTER (3));
mono_os_mutex_unlock (&mutex);
if (mono_conc_hashtable_lookup (h, GUINT_TO_POINTER (30)) != GUINT_TO_POINTER (40))
res = 1;
if (mono_conc_hashtable_lookup (h, GUINT_TO_POINTER (10)) != GUINT_TO_POINTER (20))
res = 2;
if (mono_conc_hashtable_lookup (h, GUINT_TO_POINTER (2)) != GUINT_TO_POINTER (3))
res = 3;
if (mono_conc_hashtable_lookup (h, GUINT_TO_POINTER (50)) != GUINT_TO_POINTER (60))
res = 4;
mono_conc_hashtable_destroy (h);
mono_os_mutex_destroy (&mutex);
if (res)
printf ("SERIAL TEST FAILED %d\n", res);
return res;
}
static int
single_writer_parallel_reader (void)
{
pthread_t a,b,c;
gpointer ra, rb, rc;
int i, res = 0;
ra = rb = rc = GINT_TO_POINTER (1);
mono_os_mutex_init (&global_mutex);
hash = mono_conc_hashtable_new (NULL, NULL);
pthread_create (&a, NULL, pr_sw_thread, GINT_TO_POINTER (0));
pthread_create (&b, NULL, pr_sw_thread, GINT_TO_POINTER (1));
pthread_create (&c, NULL, pr_sw_thread, GINT_TO_POINTER (2));
for (i = 0; i < 100; ++i) {
mono_os_mutex_lock (&global_mutex);
mono_conc_hashtable_insert (hash, GINT_TO_POINTER (i + 0 + 1), GINT_TO_POINTER ((i + 0) * 2 + 1));
mono_os_mutex_unlock (&global_mutex);
mono_os_mutex_lock (&global_mutex);
mono_conc_hashtable_insert (hash, GINT_TO_POINTER (i + 100 + 1), GINT_TO_POINTER ((i + 100) * 2 + 1));
mono_os_mutex_unlock (&global_mutex);
mono_os_mutex_lock (&global_mutex);
mono_conc_hashtable_insert (hash, GINT_TO_POINTER (i + 200 + 1), GINT_TO_POINTER ((i + 200) * 2 + 1));
mono_os_mutex_unlock (&global_mutex);
}
pthread_join (a, &ra);
pthread_join (b, &rb);
pthread_join (c, &rc);
res = GPOINTER_TO_INT (ra) + GPOINTER_TO_INT (rb) + GPOINTER_TO_INT (rc);
mono_conc_hashtable_destroy (hash);
mono_os_mutex_destroy (&global_mutex);
if (res)
printf ("SINGLE_WRITER_PAR_READER TEST FAILED %d\n", res);
return res;
}
void
sgen_pinning_init (void)
{
mono_os_mutex_init (&pin_queue_mutex);
}
void
mono_dynamic_images_init (void)
{
mono_os_mutex_init (&dynamic_images_mutex);
}
static void
initialize (void)
{
mono_os_mutex_init (&signal_mutex);
}