[sgen] Clear the card table in the finishing pause

[mono.git] / mono / sgen / sgen-workers.c

diff --git a/mono/sgen/sgen-workers.c b/mono/sgen/sgen-workers.c
index 590e0b6dc2d017a91a6338c4fc9b587368fcf32a..f1212c658c4c755954fba3d3927e62742cfe836e 100644 (file)
--- a/mono/sgen/sgen-workers.c
+++ b/mono/sgen/sgen-workers.c
@@ -31,6 +31,7 @@
 #include "mono/sgen/sgen-client.h"
 
 static int workers_num;
+static volatile gboolean forced_stop;
 static WorkerData *workers_data;
 
 static SgenSectionGrayQueue workers_distribute_gray_queue;
@@ -122,6 +123,8 @@ worker_try_finish (void)
 
                /* We are the last thread to go to sleep. */
        } while (!set_state (old_state, STATE_NOT_WORKING));
+
+       binary_protocol_worker_finish (sgen_timestamp (), forced_stop);
 }
 
 void
@@ -190,7 +193,7 @@ init_private_gray_queue (WorkerData *data)
 static void
 thread_pool_init_func (void *data_untyped)
 {
-       WorkerData *data = data_untyped;
+       WorkerData *data = (WorkerData *)data_untyped;
        SgenMajorCollector *major = sgen_get_major_collector ();
 
        sgen_client_thread_register_worker ();
@@ -210,7 +213,7 @@ continue_idle_func (void)
 static void
 marker_idle_func (void *data_untyped)
 {
-       WorkerData *data = data_untyped;
+       WorkerData *data = (WorkerData *)data_untyped;
 
        SGEN_ASSERT (0, continue_idle_func (), "Why are we called when we're not supposed to work?");
        SGEN_ASSERT (0, sgen_concurrent_collection_in_progress (), "The worker should only mark in concurrent collections.");
@@ -220,7 +223,7 @@ marker_idle_func (void *data_untyped)
                SGEN_ASSERT (0, workers_state != STATE_NOT_WORKING, "How did we get from WORK ENQUEUED to NOT WORKING?");
        }
 
-       if (!sgen_gray_object_queue_is_empty (&data->private_gray_queue) || workers_get_work (data)) {
+       if (!forced_stop && (!sgen_gray_object_queue_is_empty (&data->private_gray_queue) || workers_get_work (data))) {
                ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (idle_func_object_ops, &data->private_gray_queue);
 
                SGEN_ASSERT (0, !sgen_gray_object_queue_is_empty (&data->private_gray_queue), "How is our gray queue empty if we just got work?");
@@ -257,7 +260,7 @@ void
 sgen_workers_init (int num_workers)
 {
        int i;
-       void **workers_data_ptrs = alloca(num_workers * sizeof(void *));
+       void **workers_data_ptrs = (void **)alloca(num_workers * sizeof(void *));
 
        if (!sgen_get_major_collector ()->is_concurrent) {
                sgen_thread_pool_init (num_workers, thread_pool_init_func, NULL, NULL, NULL);
@@ -268,7 +271,7 @@ sgen_workers_init (int num_workers)
 
        workers_num = num_workers;
 
-       workers_data = sgen_alloc_internal_dynamic (sizeof (WorkerData) * num_workers, INTERNAL_MEM_WORKER_DATA, TRUE);
+       workers_data = (WorkerData *)sgen_alloc_internal_dynamic (sizeof (WorkerData) * num_workers, INTERNAL_MEM_WORKER_DATA, TRUE);
        memset (workers_data, 0, sizeof (WorkerData) * num_workers);
 
        init_distribute_gray_queue ();
@@ -281,9 +284,20 @@ sgen_workers_init (int num_workers)
        mono_counters_register ("# workers finished", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_workers_num_finished);
 }
 
+void
+sgen_workers_stop_all_workers (void)
+{
+       forced_stop = TRUE;
+
+       sgen_thread_pool_wait_for_all_jobs ();
+       sgen_thread_pool_idle_wait ();
+       SGEN_ASSERT (0, workers_state == STATE_NOT_WORKING, "Can only signal enqueue work when in no work state");
+}
+
 void
 sgen_workers_start_all_workers (SgenObjectOperations *object_ops)
 {
+       forced_stop = FALSE;
        idle_func_object_ops = object_ops;
        mono_memory_write_barrier ();
 
@@ -306,6 +320,28 @@ sgen_workers_join (void)
                SGEN_ASSERT (0, sgen_gray_object_queue_is_empty (&workers_data [i].private_gray_queue), "Why is there still work left to do?");
 }
 
+/*
+ * Can only be called if the workers are stopped.
+ * If we're stopped, there are also no pending jobs.
+ */
+gboolean
+sgen_workers_have_idle_work (void)
+{
+       int i;
+
+       SGEN_ASSERT (0, forced_stop && sgen_workers_all_done (), "Checking for idle work should only happen if the workers are stopped.");
+
+       if (!sgen_section_gray_queue_is_empty (&workers_distribute_gray_queue))
+               return TRUE;
+
+       for (i = 0; i < workers_num; ++i) {
+               if (!sgen_gray_object_queue_is_empty (&workers_data [i].private_gray_queue))
+                       return TRUE;
+       }
+
+       return FALSE;
+}
+
 gboolean
 sgen_workers_all_done (void)
 {
@@ -319,13 +355,6 @@ sgen_workers_are_working (void)
        return state_is_working_or_enqueued (workers_state);
 }
 
-void
-sgen_workers_wait (void)
-{
-       sgen_thread_pool_idle_wait ();
-       SGEN_ASSERT (0, sgen_workers_all_done (), "Why are the workers not done after we wait for them?");
-}
-
 SgenSectionGrayQueue*
 sgen_workers_get_distribute_section_gray_queue (void)
 {