mono/metadata/sgen-stw.c

   1 /**
   2  * \file
   3  * Stop the world functionality
   4  *
   5  * Author:
   6  *      Paolo Molaro (lupus@ximian.com)
   7  *  Rodrigo Kumpera (kumpera@gmail.com)
   8  *
   9  * Copyright 2005-2011 Novell, Inc (http://www.novell.com)
  10  * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
  11  * Copyright 2011 Xamarin, Inc.
  12  * Copyright (C) 2012 Xamarin Inc
  13  *
  14  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  15  */
  16
  17 #include "config.h"
  18 #ifdef HAVE_SGEN_GC
  19
  20 #include "sgen/sgen-gc.h"
  21 #include "sgen/sgen-protocol.h"
  22 #include "sgen/sgen-memory-governor.h"
  23 #include "sgen/sgen-workers.h"
  24 #include "metadata/profiler-private.h"
  25 #include "sgen/sgen-client.h"
  26 #include "metadata/sgen-bridge-internals.h"
  27 #include "metadata/gc-internals.h"
  28 #include "utils/mono-threads.h"
  29 #include "utils/mono-threads-debug.h"
  30
  31 #define TV_DECLARE SGEN_TV_DECLARE
  32 #define TV_GETTIME SGEN_TV_GETTIME
  33 #define TV_ELAPSED SGEN_TV_ELAPSED
  34
  35 static void sgen_unified_suspend_restart_world (void);
  36 static void sgen_unified_suspend_stop_world (void);
  37
  38 static TV_DECLARE (end_of_last_stw);
  39
  40 guint64 mono_time_since_last_stw ()
  41 {
  42         if (end_of_last_stw == 0)
  43                 return 0;
  44
  45         TV_DECLARE (current_time);
  46         TV_GETTIME (current_time);
  47         return TV_ELAPSED (end_of_last_stw, current_time);
  48 }
  49
  50 unsigned int sgen_global_stop_count = 0;
  51
  52 inline static void*
  53 align_pointer (void *ptr)
  54 {
  55         mword p = (mword)ptr;
  56         p += sizeof (gpointer) - 1;
  57         p &= ~ (sizeof (gpointer) - 1);
  58         return (void*)p;
  59 }
  60
  61 static void
  62 update_current_thread_stack (void *start)
  63 {
  64         int stack_guard = 0;
  65         SgenThreadInfo *info = mono_thread_info_current ();
  66
  67         info->client_info.stack_start = align_pointer (&stack_guard);
  68         g_assert (info->client_info.stack_start);
  69         g_assert (info->client_info.stack_start >= info->client_info.info.stack_start_limit && info->client_info.stack_start < info->client_info.info.stack_end);
  70
  71 #if !defined(MONO_CROSS_COMPILE) && MONO_ARCH_HAS_MONO_CONTEXT
  72         MONO_CONTEXT_GET_CURRENT (info->client_info.ctx);
  73 #elif defined (HOST_WASM)
  74         //nothing
  75 #else
  76         g_error ("Sgen STW requires a working mono-context");
  77 #endif
  78
  79         if (mono_gc_get_gc_callbacks ()->thread_suspend_func)
  80                 mono_gc_get_gc_callbacks ()->thread_suspend_func (info->client_info.runtime_data, NULL, &info->client_info.ctx);
  81 }
  82
  83 static void
  84 acquire_gc_locks (void)
  85 {
  86         LOCK_INTERRUPTION;
  87         mono_thread_info_suspend_lock ();
  88 }
  89
  90 static void
  91 release_gc_locks (void)
  92 {
  93         mono_thread_info_suspend_unlock ();
  94         UNLOCK_INTERRUPTION;
  95 }
  96
  97 static TV_DECLARE (stop_world_time);
  98 static unsigned long max_pause_usec = 0;
  99
 100 static guint64 time_stop_world;
 101 static guint64 time_restart_world;
 102
 103 /* LOCKING: assumes the GC lock is held */
 104 void
 105 sgen_client_stop_world (int generation, gboolean serial_collection)
 106 {
 107         TV_DECLARE (end_handshake);
 108
 109         MONO_PROFILER_RAISE (gc_event, (MONO_GC_EVENT_PRE_STOP_WORLD, generation, serial_collection));
 110
 111         acquire_gc_locks ();
 112
 113         MONO_PROFILER_RAISE (gc_event, (MONO_GC_EVENT_PRE_STOP_WORLD_LOCKED, generation, serial_collection));
 114
 115         update_current_thread_stack (&generation);
 116
 117         /* We start to scan after locks are taking, this ensures we won't be interrupted. */
 118         sgen_process_togglerefs ();
 119
 120         sgen_global_stop_count++;
 121         SGEN_LOG (3, "stopping world n %d from %p %p", sgen_global_stop_count, mono_thread_info_current (), (gpointer) (gsize) mono_native_thread_id_get ());
 122         TV_GETTIME (stop_world_time);
 123
 124         sgen_unified_suspend_stop_world ();
 125
 126         SGEN_LOG (3, "world stopped");
 127
 128         MONO_PROFILER_RAISE (gc_event, (MONO_GC_EVENT_POST_STOP_WORLD, generation, serial_collection));
 129
 130         TV_GETTIME (end_handshake);
 131         time_stop_world += TV_ELAPSED (stop_world_time, end_handshake);
 132
 133         sgen_memgov_collection_start (generation);
 134         if (sgen_need_bridge_processing ())
 135                 sgen_bridge_reset_data ();
 136 }
 137
 138 /* LOCKING: assumes the GC lock is held */
 139 void
 140 sgen_client_restart_world (int generation, gboolean serial_collection, gint64 *stw_time)
 141 {
 142         TV_DECLARE (end_sw);
 143         TV_DECLARE (start_handshake);
 144         unsigned long usec;
 145
 146         /* notify the profiler of the leftovers */
 147         /* FIXME this is the wrong spot at we can STW for non collection reasons. */
 148         if (MONO_PROFILER_ENABLED (gc_moves))
 149                 mono_sgen_gc_event_moves ();
 150
 151         if (MONO_PROFILER_ENABLED (gc_resize))
 152                 mono_sgen_gc_event_resize ();
 153
 154         MONO_PROFILER_RAISE (gc_event, (MONO_GC_EVENT_PRE_START_WORLD, generation, serial_collection));
 155
 156         FOREACH_THREAD_ALL (info) {
 157                 info->client_info.stack_start = NULL;
 158                 memset (&info->client_info.ctx, 0, sizeof (MonoContext));
 159         } FOREACH_THREAD_END
 160
 161         TV_GETTIME (start_handshake);
 162
 163         sgen_unified_suspend_restart_world ();
 164
 165         TV_GETTIME (end_sw);
 166         time_restart_world += TV_ELAPSED (start_handshake, end_sw);
 167         usec = TV_ELAPSED (stop_world_time, end_sw);
 168         max_pause_usec = MAX (usec, max_pause_usec);
 169         end_of_last_stw = end_sw;
 170
 171         SGEN_LOG (2, "restarted (pause time: %d usec, max: %d)", (int)usec, (int)max_pause_usec);
 172
 173         MONO_PROFILER_RAISE (gc_event, (MONO_GC_EVENT_POST_START_WORLD, generation, serial_collection));
 174
 175         /*
 176          * We must release the thread info suspend lock after doing
 177          * the thread handshake.  Otherwise, if the GC stops the world
 178          * and a thread is in the process of starting up, but has not
 179          * yet registered (it's not in the thread_list), it is
 180          * possible that the thread does register while the world is
 181          * stopped.  When restarting the GC will then try to restart
 182          * said thread, but since it never got the suspend signal, it
 183          * cannot answer the restart signal, so a deadlock results.
 184          */
 185         release_gc_locks ();
 186
 187         MONO_PROFILER_RAISE (gc_event, (MONO_GC_EVENT_POST_START_WORLD_UNLOCKED, generation, serial_collection));
 188
 189         *stw_time = usec;
 190 }
 191
 192 void
 193 mono_sgen_init_stw (void)
 194 {
 195         mono_counters_register ("World stop", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_stop_world);
 196         mono_counters_register ("World restart", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_restart_world);
 197 }
 198
 199 /* Unified suspend code */
 200
 201 static gboolean
 202 sgen_is_thread_in_current_stw (SgenThreadInfo *info, int *reason)
 203 {
 204         /*
 205          * No need to check MONO_THREAD_INFO_FLAGS_NO_GC here as we rely on the
 206          * FOREACH_THREAD_EXCLUDE macro to skip such threads for us.
 207          */
 208
 209         /*
 210         We have detected that this thread is failing/dying, ignore it.
 211         FIXME: can't we merge this with thread_is_dying?
 212         */
 213         if (info->client_info.skip) {
 214                 if (reason)
 215                         *reason = 2;
 216                 return FALSE;
 217         }
 218
 219         /*
 220         Suspending the current thread will deadlock us, bad idea.
 221         */
 222         if (info == mono_thread_info_current ()) {
 223                 if (reason)
 224                         *reason = 3;
 225                 return FALSE;
 226         }
 227
 228         /*
 229         We can't suspend the workers that will do all the heavy lifting.
 230         FIXME Use some state bit in SgenThreadInfo for this.
 231         */
 232         if (sgen_thread_pool_is_thread_pool_thread (mono_thread_info_get_tid (info))) {
 233                 if (reason)
 234                         *reason = 4;
 235                 return FALSE;
 236         }
 237
 238         /*
 239         The thread has signaled that it started to detach, ignore it.
 240         FIXME: can't we merge this with skip
 241         */
 242         if (!mono_thread_info_is_live (info)) {
 243                 if (reason)
 244                         *reason = 5;
 245                 return FALSE;
 246         }
 247
 248         return TRUE;
 249 }
 250
 251 static void
 252 sgen_unified_suspend_stop_world (void)
 253 {
 254         int sleep_duration = -1;
 255
 256         // we can't lead STW if we promised not to safepoint.
 257         g_assert (!mono_thread_info_will_not_safepoint (mono_thread_info_current ()));
 258
 259         mono_threads_begin_global_suspend ();
 260         THREADS_STW_DEBUG ("[GC-STW-BEGIN][%p] *** BEGIN SUSPEND *** \n", mono_thread_info_get_tid (mono_thread_info_current ()));
 261
 262         for (MonoThreadSuspendPhase phase = MONO_THREAD_SUSPEND_PHASE_INITIAL; phase < MONO_THREAD_SUSPEND_PHASE_COUNT; phase++) {
 263                 gboolean need_next_phase = FALSE;
 264                 FOREACH_THREAD_EXCLUDE (info, MONO_THREAD_INFO_FLAGS_NO_GC) {
 265                         /* look at every thread in the first phase. */
 266                         if (phase == MONO_THREAD_SUSPEND_PHASE_INITIAL) {
 267                                 info->client_info.skip = FALSE;
 268                                 info->client_info.suspend_done = FALSE;
 269                         } else {
 270                                 /* skip threads suspended by previous phase. */
 271                                 /* threads with info->client_info->skip set to TRUE will be skipped by sgen_is_thread_in_current_stw. */
 272                                 if (info->client_info.suspend_done)
 273                                         continue;
 274                         }
 275
 276                         int reason;
 277                         if (!sgen_is_thread_in_current_stw (info, &reason)) {
 278                                 THREADS_STW_DEBUG ("[GC-STW-BEGIN-SUSPEND-%d] IGNORE thread %p skip %s reason %d\n", (int)phase, mono_thread_info_get_tid (info), info->client_info.skip ? "true" : "false", reason);
 279                                 continue;
 280                         }
 281
 282                         switch (mono_thread_info_begin_suspend (info, phase)) {
 283                         case MONO_THREAD_BEGIN_SUSPEND_SUSPENDED:
 284                                 info->client_info.skip = FALSE;
 285                                 break;
 286                         case MONO_THREAD_BEGIN_SUSPEND_SKIP:
 287                                 info->client_info.skip = TRUE;
 288                                 break;
 289                         case MONO_THREAD_BEGIN_SUSPEND_NEXT_PHASE:
 290                                 need_next_phase = TRUE;
 291                                 break;
 292                         default:
 293                                 g_assert_not_reached ();
 294                         }
 295
 296                         THREADS_STW_DEBUG ("[GC-STW-BEGIN-SUSPEND-%d] SUSPEND thread %p skip %s\n", (int)phase, mono_thread_info_get_tid (info), info->client_info.skip ? "true" : "false");
 297                 } FOREACH_THREAD_END;
 298
 299                 mono_thread_info_current ()->client_info.suspend_done = TRUE;
 300                 mono_threads_wait_pending_operations ();
 301
 302                 if (!need_next_phase)
 303                         break;
 304         }
 305
 306         for (;;) {
 307                 gint restart_counter = 0;
 308
 309                 FOREACH_THREAD_EXCLUDE (info, MONO_THREAD_INFO_FLAGS_NO_GC) {
 310                         gint suspend_count;
 311
 312                         int reason = 0;
 313                         if (info->client_info.suspend_done || !sgen_is_thread_in_current_stw (info, &reason)) {
 314                                 THREADS_STW_DEBUG ("[GC-STW-RESTART] IGNORE RESUME thread %p not been processed done %d current %d reason %d\n", mono_thread_info_get_tid (info), info->client_info.suspend_done, !sgen_is_thread_in_current_stw (info, NULL), reason);
 315                                 continue;
 316                         }
 317
 318                         /*
 319                         All threads that reach here are pristine suspended. This means the following:
 320
 321                         - We haven't accepted the previous suspend as good.
 322                         - We haven't gave up on it for this STW (it's either bad or asked not to)
 323                         */
 324                         if (!mono_thread_info_in_critical_location (info)) {
 325                                 info->client_info.suspend_done = TRUE;
 326
 327                                 THREADS_STW_DEBUG ("[GC-STW-RESTART] DONE thread %p deemed fully suspended\n", mono_thread_info_get_tid (info));
 328                                 continue;
 329                         }
 330
 331                         suspend_count = mono_thread_info_suspend_count (info);
 332                         if (!(suspend_count == 1))
 333                                 g_error ("[%p] suspend_count = %d, but should be 1", mono_thread_info_get_tid (info), suspend_count);
 334
 335                         info->client_info.skip = !mono_thread_info_begin_pulse_resume_and_request_suspension (info);
 336                         if (!info->client_info.skip)
 337                                 restart_counter += 1;
 338
 339                         THREADS_STW_DEBUG ("[GC-STW-RESTART] RESTART thread %p skip %s\n", mono_thread_info_get_tid (info), info->client_info.skip ? "true" : "false");
 340                 } FOREACH_THREAD_END
 341
 342                 mono_threads_wait_pending_operations ();
 343
 344                 if (restart_counter == 0)
 345                         break;
 346
 347                 if (sleep_duration < 0) {
 348                         mono_thread_info_yield ();
 349                         sleep_duration = 0;
 350                 } else {
 351                         g_usleep (sleep_duration);
 352                         sleep_duration += 10;
 353                 }
 354
 355                 FOREACH_THREAD_EXCLUDE (info, MONO_THREAD_INFO_FLAGS_NO_GC) {
 356                         int reason = 0;
 357                         if (info->client_info.suspend_done || !sgen_is_thread_in_current_stw (info, &reason)) {
 358                                 THREADS_STW_DEBUG ("[GC-STW-RESTART] IGNORE SUSPEND thread %p not been processed done %d current %d reason %d\n", mono_thread_info_get_tid (info), info->client_info.suspend_done, !sgen_is_thread_in_current_stw (info, NULL), reason);
 359                                 continue;
 360                         }
 361
 362                         if (!mono_thread_info_is_running (info)) {
 363                                 THREADS_STW_DEBUG ("[GC-STW-RESTART] IGNORE SUSPEND thread %p not running\n", mono_thread_info_get_tid (info));
 364                                 continue;
 365                         }
 366
 367                         switch (mono_thread_info_begin_suspend (info, MONO_THREAD_SUSPEND_PHASE_MOPUP)) {
 368                         case MONO_THREAD_BEGIN_SUSPEND_SUSPENDED:
 369                                 info->client_info.skip = FALSE;
 370                                 break;
 371                         case MONO_THREAD_BEGIN_SUSPEND_SKIP:
 372                                 info->client_info.skip = TRUE;
 373                                 break;
 374                         case MONO_THREAD_BEGIN_SUSPEND_NEXT_PHASE:
 375                                 g_assert_not_reached ();
 376                         default:
 377                                 g_assert_not_reached ();
 378                         }
 379
 380                         THREADS_STW_DEBUG ("[GC-STW-RESTART] SUSPEND thread %p skip %s\n", mono_thread_info_get_tid (info), info->client_info.skip ? "true" : "false");
 381                 } FOREACH_THREAD_END
 382
 383                 mono_threads_wait_pending_operations ();
 384         }
 385
 386         FOREACH_THREAD_EXCLUDE (info, MONO_THREAD_INFO_FLAGS_NO_GC) {
 387                 gpointer stopped_ip;
 388
 389                 int reason = 0;
 390                 if (!sgen_is_thread_in_current_stw (info, &reason)) {
 391                         g_assert (!info->client_info.suspend_done || info == mono_thread_info_current ());
 392
 393                         THREADS_STW_DEBUG ("[GC-STW-SUSPEND-END] thread %p is NOT suspended, reason %d\n", mono_thread_info_get_tid (info), reason);
 394                         continue;
 395                 }
 396
 397                 g_assert (info->client_info.suspend_done);
 398
 399                 info->client_info.ctx = mono_thread_info_get_suspend_state (info)->ctx;
 400
 401                 /* Once we remove the old suspend code, we should move sgen to directly access the state in MonoThread */
 402                 info->client_info.stack_start = (gpointer) ((char*)MONO_CONTEXT_GET_SP (&info->client_info.ctx) - REDZONE_SIZE);
 403
 404                 if (info->client_info.stack_start < info->client_info.info.stack_start_limit
 405                          || info->client_info.stack_start >= info->client_info.info.stack_end) {
 406                         /*
 407                          * Thread context is in unhandled state, most likely because it is
 408                          * dying. We don't scan it.
 409                          * FIXME We should probably rework and check the valid flag instead.
 410                          */
 411                         info->client_info.stack_start = NULL;
 412                 }
 413
 414                 stopped_ip = (gpointer) (MONO_CONTEXT_GET_IP (&info->client_info.ctx));
 415
 416                 sgen_binary_protocol_thread_suspend ((gpointer) mono_thread_info_get_tid (info), stopped_ip);
 417
 418                 THREADS_STW_DEBUG ("[GC-STW-SUSPEND-END] thread %p is suspended, stopped_ip = %p, stack = %p -> %p\n",
 419                         mono_thread_info_get_tid (info), stopped_ip, info->client_info.stack_start, info->client_info.stack_start ? info->client_info.info.stack_end : NULL);
 420         } FOREACH_THREAD_END
 421 }
 422
 423 static void
 424 sgen_unified_suspend_restart_world (void)
 425 {
 426         THREADS_STW_DEBUG ("[GC-STW-END] *** BEGIN RESUME ***\n");
 427         FOREACH_THREAD_EXCLUDE (info, MONO_THREAD_INFO_FLAGS_NO_GC) {
 428                 int reason = 0;
 429                 if (sgen_is_thread_in_current_stw (info, &reason)) {
 430                         g_assert (mono_thread_info_begin_resume (info));
 431                         THREADS_STW_DEBUG ("[GC-STW-RESUME-WORLD] RESUME thread %p\n", mono_thread_info_get_tid (info));
 432
 433                         sgen_binary_protocol_thread_restart ((gpointer) mono_thread_info_get_tid (info));
 434                 } else {
 435                         THREADS_STW_DEBUG ("[GC-STW-RESUME-WORLD] IGNORE thread %p, reason %d\n", mono_thread_info_get_tid (info), reason);
 436                 }
 437         } FOREACH_THREAD_END
 438
 439         mono_threads_wait_pending_operations ();
 440         mono_threads_end_global_suspend ();
 441 }
 442 #endif