/**
* DeleteCriticalSection:
* @section: The critical section to delete.
*
* Releases all resources owned by critical section @section.
*/
void DeleteCriticalSection(WapiCriticalSection *section)
{
int ret;
ret = mono_mutex_destroy(§ion->mutex);
g_assert (ret == 0);
}
static void
cleanup (void)
{
/* we make the assumption along the code that we are
* cleaning up only if the runtime is shutting down */
g_assert (mono_runtime_is_shutting_down ());
selector_thread_wakeup ();
while (io_selector_running)
g_usleep (1000);
mono_mutex_destroy (&threadpool_io->updates_lock);
mono_cond_destroy (&threadpool_io->updates_cond);
threadpool_io->backend.cleanup ();
#if !defined(HOST_WIN32)
close (threadpool_io->wakeup_pipes [0]);
close (threadpool_io->wakeup_pipes [1]);
#else
closesocket (threadpool_io->wakeup_pipes [0]);
closesocket (threadpool_io->wakeup_pipes [1]);
#endif
g_assert (threadpool_io);
g_free (threadpool_io);
threadpool_io = NULL;
g_assert (!threadpool_io);
}
/**
* DeleteCriticalSection:
* @section: The critical section to delete.
*
* Releases all resources owned by critical section @section.
*/
void DeleteCriticalSection(WapiCriticalSection *section)
{
int ret;
ret = mono_mutex_destroy(§ion->mutex);
if (ret)
g_error ("Failed to destroy mutex %p error code %d errno %d", §ion->mutex, ret, errno);
}
static void
free_thread_info (gpointer mem)
{
MonoThreadInfo *info = mem;
mono_mutex_destroy (&info->suspend_lock);
MONO_SEM_DESTROY (&info->resume_semaphore);
MONO_SEM_DESTROY (&info->finish_resume_semaphore);
mono_threads_platform_free (info);
g_free (info);
}
void
mono_unwind_cleanup (void)
{
int i;
mono_mutex_destroy (&unwind_mutex);
if (!cached_info)
return;
for (i = 0; i < cached_info_next; ++i) {
MonoUnwindInfo *cached = cached_info [i];
g_free (cached);
}
g_free (cached_info);
}
static void
ensure_cleanedup (void)
{
if (status == STATUS_NOT_INITIALIZED && InterlockedCompareExchange (&status, STATUS_CLEANED_UP, STATUS_NOT_INITIALIZED) == STATUS_NOT_INITIALIZED)
return;
if (status == STATUS_INITIALIZING) {
while (status == STATUS_INITIALIZING)
mono_thread_info_yield ();
}
if (status == STATUS_CLEANED_UP)
return;
if (status == STATUS_CLEANING_UP || InterlockedCompareExchange (&status, STATUS_CLEANING_UP, STATUS_INITIALIZED) != STATUS_INITIALIZED) {
while (status == STATUS_CLEANING_UP)
mono_thread_info_yield ();
g_assert (status == STATUS_CLEANED_UP);
return;
}
/* we make the assumption along the code that we are
* cleaning up only if the runtime is shutting down */
g_assert (mono_runtime_is_shutting_down ());
/* Unpark all worker threads */
mono_mutex_lock (&threadpool->parked_threads_lock);
for (;;) {
guint i;
ThreadPoolCounter counter = COUNTER_READ ();
if (counter._.active == 0 && counter._.parked == 0)
break;
if (counter._.active == 1) {
MonoInternalThread *thread = mono_thread_internal_current ();
if (thread->threadpool_thread) {
/* if there is only one active thread
* left and it's the current one */
break;
}
}
for (i = 0; i < threadpool->parked_threads->len; ++i) {
mono_cond_t *cond = (mono_cond_t*) g_ptr_array_index (threadpool->parked_threads, i);
mono_cond_signal (cond);
}
mono_mutex_unlock (&threadpool->parked_threads_lock);
usleep (1000);
mono_mutex_lock (&threadpool->parked_threads_lock);
}
mono_mutex_unlock (&threadpool->parked_threads_lock);
while (monitor_status != MONITOR_STATUS_NOT_RUNNING)
usleep (1000);
g_ptr_array_free (threadpool->domains, TRUE);
mono_mutex_destroy (&threadpool->domains_lock);
g_ptr_array_free (threadpool->parked_threads, TRUE);
mono_mutex_destroy (&threadpool->parked_threads_lock);
g_ptr_array_free (threadpool->working_threads, TRUE);
mono_mutex_destroy (&threadpool->working_threads_lock);
mono_mutex_destroy (&threadpool->heuristic_lock);
g_free (threadpool->heuristic_hill_climbing.samples);
g_free (threadpool->heuristic_hill_climbing.thread_counts);
rand_free (threadpool->heuristic_hill_climbing.random_interval_generator);
g_free (threadpool->cpu_usage_state);
g_assert (threadpool);
g_free (threadpool);
threadpool = NULL;
g_assert (!threadpool);
status = STATUS_CLEANED_UP;
}
static void profiler_shutdown (MonoProfiler *prof)
{
print_mismatched_stats (prof);
mono_mutex_destroy (&mismatched_files_section);
}