mono/sgen/sgen-gc.c

   1 /**
   2  * \file
   3  * Simple generational GC.
   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  *
  12  * Thread start/stop adapted from Boehm's GC:
  13  * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
  14  * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
  15  * Copyright (c) 1998 by Fergus Henderson.  All rights reserved.
  16  * Copyright (c) 2000-2004 by Hewlett-Packard Company.  All rights reserved.
  17  * Copyright 2001-2003 Ximian, Inc
  18  * Copyright 2003-2010 Novell, Inc.
  19  * Copyright 2011 Xamarin, Inc.
  20  * Copyright (C) 2012 Xamarin Inc
  21  *
  22  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  23  *
  24  * Important: allocation provides always zeroed memory, having to do
  25  * a memset after allocation is deadly for performance.
  26  * Memory usage at startup is currently as follows:
  27  * 64 KB pinned space
  28  * 64 KB internal space
  29  * size of nursery
  30  * We should provide a small memory config with half the sizes
  31  *
  32  * We currently try to make as few mono assumptions as possible:
  33  * 1) 2-word header with no GC pointers in it (first vtable, second to store the
  34  *    forwarding ptr)
  35  * 2) gc descriptor is the second word in the vtable (first word in the class)
  36  * 3) 8 byte alignment is the minimum and enough (not true for special structures (SIMD), FIXME)
  37  * 4) there is a function to get an object's size and the number of
  38  *    elements in an array.
  39  * 5) we know the special way bounds are allocated for complex arrays
  40  * 6) we know about proxies and how to treat them when domains are unloaded
  41  *
  42  * Always try to keep stack usage to a minimum: no recursive behaviour
  43  * and no large stack allocs.
  44  *
  45  * General description.
  46  * Objects are initially allocated in a nursery using a fast bump-pointer technique.
  47  * When the nursery is full we start a nursery collection: this is performed with a
  48  * copying GC.
  49  * When the old generation is full we start a copying GC of the old generation as well:
  50  * this will be changed to mark&sweep with copying when fragmentation becomes to severe
  51  * in the future.  Maybe we'll even do both during the same collection like IMMIX.
  52  *
  53  * The things that complicate this description are:
  54  * *) pinned objects: we can't move them so we need to keep track of them
  55  * *) no precise info of the thread stacks and registers: we need to be able to
  56  *    quickly find the objects that may be referenced conservatively and pin them
  57  *    (this makes the first issues more important)
  58  * *) large objects are too expensive to be dealt with using copying GC: we handle them
  59  *    with mark/sweep during major collections
  60  * *) some objects need to not move even if they are small (interned strings, Type handles):
  61  *    we use mark/sweep for them, too: they are not allocated in the nursery, but inside
  62  *    PinnedChunks regions
  63  */
  64
  65 /*
  66  * TODO:
  67
  68  *) we could have a function pointer in MonoClass to implement
  69   customized write barriers for value types
  70
  71  *) investigate the stuff needed to advance a thread to a GC-safe
  72   point (single-stepping, read from unmapped memory etc) and implement it.
  73   This would enable us to inline allocations and write barriers, for example,
  74   or at least parts of them, like the write barrier checks.
  75   We may need this also for handling precise info on stacks, even simple things
  76   as having uninitialized data on the stack and having to wait for the prolog
  77   to zero it. Not an issue for the last frame that we scan conservatively.
  78   We could always not trust the value in the slots anyway.
  79
  80  *) modify the jit to save info about references in stack locations:
  81   this can be done just for locals as a start, so that at least
  82   part of the stack is handled precisely.
  83
  84  *) test/fix endianess issues
  85
  86  *) Implement a card table as the write barrier instead of remembered
  87     sets?  Card tables are not easy to implement with our current
  88     memory layout.  We have several different kinds of major heap
  89     objects: Small objects in regular blocks, small objects in pinned
  90     chunks and LOS objects.  If we just have a pointer we have no way
  91     to tell which kind of object it points into, therefore we cannot
  92     know where its card table is.  The least we have to do to make
  93     this happen is to get rid of write barriers for indirect stores.
  94     (See next item)
  95
  96  *) Get rid of write barriers for indirect stores.  We can do this by
  97     telling the GC to wbarrier-register an object once we do an ldloca
  98     or ldelema on it, and to unregister it once it's not used anymore
  99     (it can only travel downwards on the stack).  The problem with
 100     unregistering is that it needs to happen eventually no matter
 101     what, even if exceptions are thrown, the thread aborts, etc.
 102     Rodrigo suggested that we could do only the registering part and
 103     let the collector find out (pessimistically) when it's safe to
 104     unregister, namely when the stack pointer of the thread that
 105     registered the object is higher than it was when the registering
 106     happened.  This might make for a good first implementation to get
 107     some data on performance.
 108
 109  *) Some sort of blacklist support?  Blacklists is a concept from the
 110     Boehm GC: if during a conservative scan we find pointers to an
 111     area which we might use as heap, we mark that area as unusable, so
 112     pointer retention by random pinning pointers is reduced.
 113
 114  *) experiment with max small object size (very small right now - 2kb,
 115     because it's tied to the max freelist size)
 116
 117   *) add an option to mmap the whole heap in one chunk: it makes for many
 118      simplifications in the checks (put the nursery at the top and just use a single
 119      check for inclusion/exclusion): the issue this has is that on 32 bit systems it's
 120      not flexible (too much of the address space may be used by default or we can't
 121      increase the heap as needed) and we'd need a race-free mechanism to return memory
 122      back to the system (mprotect(PROT_NONE) will still keep the memory allocated if it
 123      was written to, munmap is needed, but the following mmap may not find the same segment
 124      free...)
 125
 126  *) memzero the major fragments after restarting the world and optionally a smaller
 127     chunk at a time
 128
 129  *) investigate having fragment zeroing threads
 130
 131  *) separate locks for finalization and other minor stuff to reduce
 132     lock contention
 133
 134  *) try a different copying order to improve memory locality
 135
 136  *) a thread abort after a store but before the write barrier will
 137     prevent the write barrier from executing
 138
 139  *) specialized dynamically generated markers/copiers
 140
 141  *) Dynamically adjust TLAB size to the number of threads.  If we have
 142     too many threads that do allocation, we might need smaller TLABs,
 143     and we might get better performance with larger TLABs if we only
 144     have a handful of threads.  We could sum up the space left in all
 145     assigned TLABs and if that's more than some percentage of the
 146     nursery size, reduce the TLAB size.
 147
 148  *) Explore placing unreachable objects on unused nursery memory.
 149         Instead of memset'ng a region to zero, place an int[] covering it.
 150         A good place to start is add_nursery_frag. The tricky thing here is
 151         placing those objects atomically outside of a collection.
 152
 153  *) Allocation should use asymmetric Dekker synchronization:
 154         http://blogs.oracle.com/dave/resource/Asymmetric-Dekker-Synchronization.txt
 155         This should help weak consistency archs.
 156  */
 157 #include "config.h"
 158 #ifdef HAVE_SGEN_GC
 159
 160 #ifdef __MACH__
 161 #undef _XOPEN_SOURCE
 162 #define _XOPEN_SOURCE
 163 #define _DARWIN_C_SOURCE
 164 #endif
 165
 166 #ifdef HAVE_UNISTD_H
 167 #include <unistd.h>
 168 #endif
 169 #ifdef HAVE_PTHREAD_H
 170 #include <pthread.h>
 171 #endif
 172 #ifdef HAVE_PTHREAD_NP_H
 173 #include <pthread_np.h>
 174 #endif
 175 #include <stdio.h>
 176 #include <string.h>
 177 #include <errno.h>
 178 #include <assert.h>
 179 #include <stdlib.h>
 180 #include <glib.h>
 181
 182 #include "mono/sgen/sgen-gc.h"
 183 #include "mono/sgen/sgen-cardtable.h"
 184 #include "mono/sgen/sgen-protocol.h"
 185 #include "mono/sgen/sgen-memory-governor.h"
 186 #include "mono/sgen/sgen-hash-table.h"
 187 #include "mono/sgen/sgen-pinning.h"
 188 #include "mono/sgen/sgen-workers.h"
 189 #include "mono/sgen/sgen-client.h"
 190 #include "mono/sgen/sgen-pointer-queue.h"
 191 #include "mono/sgen/gc-internal-agnostic.h"
 192 #include "mono/utils/mono-proclib.h"
 193 #include "mono/utils/mono-memory-model.h"
 194 #include "mono/utils/hazard-pointer.h"
 195
 196 #include <mono/utils/memcheck.h>
 197 #include <mono/utils/mono-mmap-internals.h>
 198 #include <mono/utils/unlocked.h>
 199
 200 #undef pthread_create
 201 #undef pthread_join
 202 #undef pthread_detach
 203
 204 /*
 205  * ######################################################################
 206  * ########  Types and constants used by the GC.
 207  * ######################################################################
 208  */
 209
 210 /* 0 means not initialized, 1 is initialized, -1 means in progress */
 211 static int gc_initialized = 0;
 212 /* If set, check if we need to do something every X allocations */
 213 gboolean has_per_allocation_action;
 214 /* If set, do a heap check every X allocation */
 215 guint32 verify_before_allocs = 0;
 216 /* If set, do a minor collection before every X allocation */
 217 guint32 collect_before_allocs = 0;
 218 /* If set, do a whole heap check before each collection */
 219 static gboolean whole_heap_check_before_collection = FALSE;
 220 /* If set, do a remset consistency check at various opportunities */
 221 static gboolean remset_consistency_checks = FALSE;
 222 /* If set, do a mod union consistency check before each finishing collection pause */
 223 static gboolean mod_union_consistency_check = FALSE;
 224 /* If set, check whether mark bits are consistent after major collections */
 225 static gboolean check_mark_bits_after_major_collection = FALSE;
 226 /* If set, check that all nursery objects are pinned/not pinned, depending on context */
 227 static gboolean check_nursery_objects_pinned = FALSE;
 228 /* If set, do a few checks when the concurrent collector is used */
 229 static gboolean do_concurrent_checks = FALSE;
 230 /* If set, do a plausibility check on the scan_starts before and after
 231    each collection */
 232 static gboolean do_scan_starts_check = FALSE;
 233
 234 static gboolean disable_minor_collections = FALSE;
 235 static gboolean disable_major_collections = FALSE;
 236 static gboolean do_verify_nursery = FALSE;
 237 static gboolean do_dump_nursery_content = FALSE;
 238 static gboolean enable_nursery_canaries = FALSE;
 239
 240 static gboolean precleaning_enabled = TRUE;
 241 static gboolean dynamic_nursery = FALSE;
 242 static size_t min_nursery_size = 0;
 243 static size_t max_nursery_size = 0;
 244
 245 #ifdef HEAVY_STATISTICS
 246 guint64 stat_objects_alloced_degraded = 0;
 247 guint64 stat_bytes_alloced_degraded = 0;
 248
 249 guint64 stat_copy_object_called_nursery = 0;
 250 guint64 stat_objects_copied_nursery = 0;
 251 guint64 stat_copy_object_called_major = 0;
 252 guint64 stat_objects_copied_major = 0;
 253
 254 guint64 stat_scan_object_called_nursery = 0;
 255 guint64 stat_scan_object_called_major = 0;
 256
 257 guint64 stat_slots_allocated_in_vain;
 258
 259 guint64 stat_nursery_copy_object_failed_from_space = 0;
 260 guint64 stat_nursery_copy_object_failed_forwarded = 0;
 261 guint64 stat_nursery_copy_object_failed_pinned = 0;
 262 guint64 stat_nursery_copy_object_failed_to_space = 0;
 263
 264 static guint64 stat_wbarrier_add_to_global_remset = 0;
 265 static guint64 stat_wbarrier_arrayref_copy = 0;
 266 static guint64 stat_wbarrier_generic_store = 0;
 267 static guint64 stat_wbarrier_generic_store_atomic = 0;
 268 static guint64 stat_wbarrier_set_root = 0;
 269 #endif
 270
 271 static guint64 stat_pinned_objects = 0;
 272
 273 static guint64 time_minor_pre_collection_fragment_clear = 0;
 274 static guint64 time_minor_pinning = 0;
 275 static guint64 time_minor_scan_remsets = 0;
 276 static guint64 time_minor_scan_major_blocks = 0;
 277 static guint64 time_minor_scan_los = 0;
 278 static guint64 time_minor_scan_pinned = 0;
 279 static guint64 time_minor_scan_roots = 0;
 280 static guint64 time_minor_finish_gray_stack = 0;
 281 static guint64 time_minor_fragment_creation = 0;
 282
 283 static guint64 time_major_pre_collection_fragment_clear = 0;
 284 static guint64 time_major_pinning = 0;
 285 static guint64 time_major_scan_pinned = 0;
 286 static guint64 time_major_scan_roots = 0;
 287 static guint64 time_major_scan_mod_union_blocks = 0;
 288 static guint64 time_major_scan_mod_union_los = 0;
 289 static guint64 time_major_finish_gray_stack = 0;
 290 static guint64 time_major_free_bigobjs = 0;
 291 static guint64 time_major_los_sweep = 0;
 292 static guint64 time_major_sweep = 0;
 293 static guint64 time_major_fragment_creation = 0;
 294
 295 static guint64 time_max = 0;
 296
 297 static int sgen_max_pause_time = SGEN_DEFAULT_MAX_PAUSE_TIME;
 298 static float sgen_max_pause_margin = SGEN_DEFAULT_MAX_PAUSE_MARGIN;
 299
 300 static SGEN_TV_DECLARE (time_major_conc_collection_start);
 301 static SGEN_TV_DECLARE (time_major_conc_collection_end);
 302
 303 int gc_debug_level = 0;
 304 FILE* gc_debug_file;
 305 static char* gc_params_options;
 306 static char* gc_debug_options;
 307
 308 /*
 309 void
 310 mono_gc_flush_info (void)
 311 {
 312         fflush (gc_debug_file);
 313 }
 314 */
 315
 316 #define TV_DECLARE SGEN_TV_DECLARE
 317 #define TV_GETTIME SGEN_TV_GETTIME
 318 #define TV_ELAPSED SGEN_TV_ELAPSED
 319
 320 static SGEN_TV_DECLARE (sgen_init_timestamp);
 321
 322 NurseryClearPolicy nursery_clear_policy = CLEAR_AT_TLAB_CREATION;
 323
 324 #define object_is_forwarded     SGEN_OBJECT_IS_FORWARDED
 325 #define object_is_pinned        SGEN_OBJECT_IS_PINNED
 326 #define pin_object              SGEN_PIN_OBJECT
 327
 328 #define ptr_in_nursery sgen_ptr_in_nursery
 329
 330 #define LOAD_VTABLE     SGEN_LOAD_VTABLE
 331
 332 gboolean
 333 nursery_canaries_enabled (void)
 334 {
 335         return enable_nursery_canaries;
 336 }
 337
 338 #define safe_object_get_size    sgen_safe_object_get_size
 339
 340 typedef enum {
 341         SGEN_MAJOR_DEFAULT,
 342         SGEN_MAJOR_SERIAL,
 343         SGEN_MAJOR_CONCURRENT,
 344         SGEN_MAJOR_CONCURRENT_PARALLEL
 345 } SgenMajor;
 346
 347 typedef enum {
 348         SGEN_MINOR_DEFAULT,
 349         SGEN_MINOR_SIMPLE,
 350         SGEN_MINOR_SIMPLE_PARALLEL,
 351         SGEN_MINOR_SPLIT
 352 } SgenMinor;
 353
 354 typedef enum {
 355         SGEN_MODE_NONE,
 356         SGEN_MODE_BALANCED,
 357         SGEN_MODE_THROUGHPUT,
 358         SGEN_MODE_PAUSE
 359 } SgenMode;
 360
 361 /*
 362  * ######################################################################
 363  * ########  Global data.
 364  * ######################################################################
 365  */
 366 MonoCoopMutex gc_mutex;
 367
 368 #define SCAN_START_SIZE SGEN_SCAN_START_SIZE
 369
 370 size_t degraded_mode = 0;
 371
 372 static mword bytes_pinned_from_failed_allocation = 0;
 373
 374 GCMemSection *nursery_section = NULL;
 375 static volatile mword lowest_heap_address = ~(mword)0;
 376 static volatile mword highest_heap_address = 0;
 377
 378 MonoCoopMutex sgen_interruption_mutex;
 379
 380 int current_collection_generation = -1;
 381 volatile gboolean concurrent_collection_in_progress = FALSE;
 382
 383 /* objects that are ready to be finalized */
 384 static SgenPointerQueue fin_ready_queue = SGEN_POINTER_QUEUE_INIT (INTERNAL_MEM_FINALIZE_READY);
 385 static SgenPointerQueue critical_fin_queue = SGEN_POINTER_QUEUE_INIT (INTERNAL_MEM_FINALIZE_READY);
 386
 387 /* registered roots: the key to the hash is the root start address */
 388 /*
 389  * Different kinds of roots are kept separate to speed up pin_from_roots () for example.
 390  */
 391 SgenHashTable roots_hash [ROOT_TYPE_NUM] = {
 392         SGEN_HASH_TABLE_INIT (INTERNAL_MEM_ROOTS_TABLE, INTERNAL_MEM_ROOT_RECORD, sizeof (RootRecord), sgen_aligned_addr_hash, NULL),
 393         SGEN_HASH_TABLE_INIT (INTERNAL_MEM_ROOTS_TABLE, INTERNAL_MEM_ROOT_RECORD, sizeof (RootRecord), sgen_aligned_addr_hash, NULL),
 394         SGEN_HASH_TABLE_INIT (INTERNAL_MEM_ROOTS_TABLE, INTERNAL_MEM_ROOT_RECORD, sizeof (RootRecord), sgen_aligned_addr_hash, NULL)
 395 };
 396 static mword roots_size = 0; /* amount of memory in the root set */
 397
 398 /* The size of a TLAB */
 399 /* The bigger the value, the less often we have to go to the slow path to allocate a new
 400  * one, but the more space is wasted by threads not allocating much memory.
 401  * FIXME: Tune this.
 402  * FIXME: Make this self-tuning for each thread.
 403  */
 404 guint32 tlab_size = (1024 * 4);
 405
 406 #define MAX_SMALL_OBJ_SIZE      SGEN_MAX_SMALL_OBJ_SIZE
 407
 408 #define ALLOC_ALIGN             SGEN_ALLOC_ALIGN
 409
 410 #define ALIGN_UP                SGEN_ALIGN_UP
 411
 412 #ifdef SGEN_DEBUG_INTERNAL_ALLOC
 413 MonoNativeThreadId main_gc_thread = NULL;
 414 #endif
 415
 416 /*Object was pinned during the current collection*/
 417 static mword objects_pinned;
 418
 419 /*
 420  * ######################################################################
 421  * ########  Macros and function declarations.
 422  * ######################################################################
 423  */
 424
 425 /* forward declarations */
 426 static void scan_from_registered_roots (char *addr_start, char *addr_end, int root_type, ScanCopyContext ctx);
 427
 428 static void pin_from_roots (void *start_nursery, void *end_nursery, ScanCopyContext ctx);
 429 static void finish_gray_stack (int generation, ScanCopyContext ctx);
 430
 431
 432 SgenMajorCollector major_collector;
 433 SgenMinorCollector sgen_minor_collector;
 434
 435 static SgenRememberedSet remset;
 436
 437 /*
 438  * The gray queue a worker job must use.  If we're not parallel or
 439  * concurrent, we use the main gray queue.
 440  */
 441 static SgenGrayQueue*
 442 sgen_workers_get_job_gray_queue (WorkerData *worker_data, SgenGrayQueue *default_gray_queue)
 443 {
 444         if (worker_data)
 445                 return &worker_data->private_gray_queue;
 446         SGEN_ASSERT (0, default_gray_queue, "Why don't we have a default gray queue when we're not running in a worker thread?");
 447         return default_gray_queue;
 448 }
 449
 450 static void
 451 gray_queue_redirect (SgenGrayQueue *queue)
 452 {
 453         sgen_workers_take_from_queue (current_collection_generation, queue);
 454 }
 455
 456 void
 457 sgen_scan_area_with_callback (char *start, char *end, IterateObjectCallbackFunc callback, void *data, gboolean allow_flags, gboolean fail_on_canaries)
 458 {
 459         while (start < end) {
 460                 size_t size;
 461                 char *obj;
 462
 463                 if (!*(void**)start) {
 464                         start += sizeof (void*); /* should be ALLOC_ALIGN, really */
 465                         continue;
 466                 }
 467
 468                 if (allow_flags) {
 469                         if (!(obj = (char *)SGEN_OBJECT_IS_FORWARDED (start)))
 470                                 obj = start;
 471                 } else {
 472                         obj = start;
 473                 }
 474
 475                 if (!sgen_client_object_is_array_fill ((GCObject*)obj)) {
 476                         CHECK_CANARY_FOR_OBJECT ((GCObject*)obj, fail_on_canaries);
 477                         size = ALIGN_UP (safe_object_get_size ((GCObject*)obj));
 478                         callback ((GCObject*)obj, size, data);
 479                         CANARIFY_SIZE (size);
 480                 } else {
 481                         size = ALIGN_UP (safe_object_get_size ((GCObject*)obj));
 482                 }
 483
 484                 start += size;
 485         }
 486 }
 487
 488 /*
 489  * sgen_add_to_global_remset:
 490  *
 491  *   The global remset contains locations which point into newspace after
 492  * a minor collection. This can happen if the objects they point to are pinned.
 493  *
 494  * LOCKING: If called from a parallel collector, the global remset
 495  * lock must be held.  For serial collectors that is not necessary.
 496  */
 497 void
 498 sgen_add_to_global_remset (gpointer ptr, GCObject *obj)
 499 {
 500         SGEN_ASSERT (5, sgen_ptr_in_nursery (obj), "Target pointer of global remset must be in the nursery");
 501
 502         HEAVY_STAT (++stat_wbarrier_add_to_global_remset);
 503
 504         if (!major_collector.is_concurrent) {
 505                 SGEN_ASSERT (5, current_collection_generation != -1, "Global remsets can only be added during collections");
 506         } else {
 507                 if (current_collection_generation == -1)
 508                         SGEN_ASSERT (5, sgen_concurrent_collection_in_progress (), "Global remsets outside of collection pauses can only be added by the concurrent collector");
 509         }
 510
 511         if (!object_is_pinned (obj))
 512                 SGEN_ASSERT (5, sgen_minor_collector.is_split || sgen_concurrent_collection_in_progress (), "Non-pinned objects can only remain in nursery if it is a split nursery");
 513         else if (sgen_cement_lookup_or_register (obj))
 514                 return;
 515
 516         remset.record_pointer (ptr);
 517
 518         sgen_pin_stats_register_global_remset (obj);
 519
 520         SGEN_LOG (8, "Adding global remset for %p", ptr);
 521         binary_protocol_global_remset (ptr, obj, (gpointer)SGEN_LOAD_VTABLE (obj));
 522 }
 523
 524 /*
 525  * sgen_drain_gray_stack:
 526  *
 527  *   Scan objects in the gray stack until the stack is empty. This should be called
 528  * frequently after each object is copied, to achieve better locality and cache
 529  * usage.
 530  *
 531  */
 532 gboolean
 533 sgen_drain_gray_stack (ScanCopyContext ctx)
 534 {
 535         SGEN_ASSERT (0, ctx.ops->drain_gray_stack, "Why do we have a scan/copy context with a missing drain gray stack function?");
 536
 537         return ctx.ops->drain_gray_stack (ctx.queue);
 538 }
 539
 540 /*
 541  * Addresses in the pin queue are already sorted. This function finds
 542  * the object header for each address and pins the object. The
 543  * addresses must be inside the nursery section.  The (start of the)
 544  * address array is overwritten with the addresses of the actually
 545  * pinned objects.  Return the number of pinned objects.
 546  */
 547 static int
 548 pin_objects_from_nursery_pin_queue (gboolean do_scan_objects, ScanCopyContext ctx)
 549 {
 550         GCMemSection *section = nursery_section;
 551         void **start =  sgen_pinning_get_entry (section->pin_queue_first_entry);
 552         void **end = sgen_pinning_get_entry (section->pin_queue_last_entry);
 553         void *start_nursery = section->data;
 554         void *end_nursery = section->end_data;
 555         void *last = NULL;
 556         int count = 0;
 557         void *search_start;
 558         void *addr;
 559         void *pinning_front = start_nursery;
 560         size_t idx;
 561         void **definitely_pinned = start;
 562         ScanObjectFunc scan_func = ctx.ops->scan_object;
 563         SgenGrayQueue *queue = ctx.queue;
 564
 565         sgen_nursery_allocator_prepare_for_pinning ();
 566
 567         while (start < end) {
 568                 GCObject *obj_to_pin = NULL;
 569                 size_t obj_to_pin_size = 0;
 570                 SgenDescriptor desc;
 571
 572                 addr = *start;
 573
 574                 SGEN_ASSERT (0, addr >= start_nursery && addr < end_nursery, "Potential pinning address out of range");
 575                 SGEN_ASSERT (0, addr >= last, "Pin queue not sorted");
 576
 577                 if (addr == last) {
 578                         ++start;
 579                         continue;
 580                 }
 581
 582                 SGEN_LOG (5, "Considering pinning addr %p", addr);
 583                 /* We've already processed everything up to pinning_front. */
 584                 if (addr < pinning_front) {
 585                         start++;
 586                         continue;
 587                 }
 588
 589                 /*
 590                  * Find the closest scan start <= addr.  We might search backward in the
 591                  * scan_starts array because entries might be NULL.  In the worst case we
 592                  * start at start_nursery.
 593                  */
 594                 idx = ((char*)addr - (char*)section->data) / SCAN_START_SIZE;
 595                 SGEN_ASSERT (0, idx < section->num_scan_start, "Scan start index out of range");
 596                 search_start = (void*)section->scan_starts [idx];
 597                 if (!search_start || search_start > addr) {
 598                         while (idx) {
 599                                 --idx;
 600                                 search_start = section->scan_starts [idx];
 601                                 if (search_start && search_start <= addr)
 602                                         break;
 603                         }
 604                         if (!search_start || search_start > addr)
 605                                 search_start = start_nursery;
 606                 }
 607
 608                 /*
 609                  * If the pinning front is closer than the scan start we found, start
 610                  * searching at the front.
 611                  */
 612                 if (search_start < pinning_front)
 613                         search_start = pinning_front;
 614
 615                 /*
 616                  * Now addr should be in an object a short distance from search_start.
 617                  *
 618                  * search_start must point to zeroed mem or point to an object.
 619                  */
 620                 do {
 621                         size_t obj_size, canarified_obj_size;
 622
 623                         /* Skip zeros. */
 624                         if (!*(void**)search_start) {
 625                                 search_start = (void*)ALIGN_UP ((mword)search_start + sizeof (gpointer));
 626                                 /* The loop condition makes sure we don't overrun addr. */
 627                                 continue;
 628                         }
 629
 630                         canarified_obj_size = obj_size = ALIGN_UP (safe_object_get_size ((GCObject*)search_start));
 631
 632                         /*
 633                          * Filler arrays are marked by an invalid sync word.  We don't
 634                          * consider them for pinning.  They are not delimited by canaries,
 635                          * either.
 636                          */
 637                         if (!sgen_client_object_is_array_fill ((GCObject*)search_start)) {
 638                                 CHECK_CANARY_FOR_OBJECT (search_start, TRUE);
 639                                 CANARIFY_SIZE (canarified_obj_size);
 640
 641                                 if (addr >= search_start && (char*)addr < (char*)search_start + obj_size) {
 642                                         /* This is the object we're looking for. */
 643                                         obj_to_pin = (GCObject*)search_start;
 644                                         obj_to_pin_size = canarified_obj_size;
 645                                         break;
 646                                 }
 647                         }
 648
 649                         /* Skip to the next object */
 650                         search_start = (void*)((char*)search_start + canarified_obj_size);
 651                 } while (search_start <= addr);
 652
 653                 /* We've searched past the address we were looking for. */
 654                 if (!obj_to_pin) {
 655                         pinning_front = search_start;
 656                         goto next_pin_queue_entry;
 657                 }
 658
 659                 /*
 660                  * We've found an object to pin.  It might still be a dummy array, but we
 661                  * can advance the pinning front in any case.
 662                  */
 663                 pinning_front = (char*)obj_to_pin + obj_to_pin_size;
 664
 665                 /*
 666                  * If this is a dummy array marking the beginning of a nursery
 667                  * fragment, we don't pin it.
 668                  */
 669                 if (sgen_client_object_is_array_fill (obj_to_pin))
 670                         goto next_pin_queue_entry;
 671
 672                 /*
 673                  * Finally - pin the object!
 674                  */
 675                 desc = sgen_obj_get_descriptor_safe (obj_to_pin);
 676                 if (do_scan_objects) {
 677                         scan_func (obj_to_pin, desc, queue);
 678                 } else {
 679                         SGEN_LOG (4, "Pinned object %p, vtable %p (%s), count %d\n",
 680                                         obj_to_pin, *(void**)obj_to_pin, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (obj_to_pin)), count);
 681                         binary_protocol_pin (obj_to_pin,
 682                                         (gpointer)LOAD_VTABLE (obj_to_pin),
 683                                         safe_object_get_size (obj_to_pin));
 684
 685                         pin_object (obj_to_pin);
 686                         GRAY_OBJECT_ENQUEUE_SERIAL (queue, obj_to_pin, desc);
 687                         sgen_pin_stats_register_object (obj_to_pin, GENERATION_NURSERY);
 688                         definitely_pinned [count] = obj_to_pin;
 689                         count++;
 690                 }
 691                 if (concurrent_collection_in_progress)
 692                         sgen_pinning_register_pinned_in_nursery (obj_to_pin);
 693
 694         next_pin_queue_entry:
 695                 last = addr;
 696                 ++start;
 697         }
 698         sgen_client_nursery_objects_pinned (definitely_pinned, count);
 699         stat_pinned_objects += count;
 700         return count;
 701 }
 702
 703 static void
 704 pin_objects_in_nursery (gboolean do_scan_objects, ScanCopyContext ctx)
 705 {
 706         size_t reduced_to;
 707
 708         if (nursery_section->pin_queue_first_entry == nursery_section->pin_queue_last_entry)
 709                 return;
 710
 711         reduced_to = pin_objects_from_nursery_pin_queue (do_scan_objects, ctx);
 712         nursery_section->pin_queue_last_entry = nursery_section->pin_queue_first_entry + reduced_to;
 713 }
 714
 715 /*
 716  * This function is only ever called (via `collector_pin_object()` in `sgen-copy-object.h`)
 717  * when we can't promote an object because we're out of memory.
 718  */
 719 void
 720 sgen_pin_object (GCObject *object, SgenGrayQueue *queue)
 721 {
 722         SGEN_ASSERT (0, sgen_ptr_in_nursery (object), "We're only supposed to use this for pinning nursery objects when out of memory.");
 723
 724         /*
 725          * All pinned objects are assumed to have been staged, so we need to stage as well.
 726          * Also, the count of staged objects shows that "late pinning" happened.
 727          */
 728         sgen_pin_stage_ptr (object);
 729
 730         SGEN_PIN_OBJECT (object);
 731         binary_protocol_pin (object, (gpointer)LOAD_VTABLE (object), safe_object_get_size (object));
 732
 733         ++objects_pinned;
 734         sgen_pin_stats_register_object (object, GENERATION_NURSERY);
 735
 736         GRAY_OBJECT_ENQUEUE_SERIAL (queue, object, sgen_obj_get_descriptor_safe (object));
 737 }
 738
 739 /* Sort the addresses in array in increasing order.
 740  * Done using a by-the book heap sort. Which has decent and stable performance, is pretty cache efficient.
 741  */
 742 void
 743 sgen_sort_addresses (void **array, size_t size)
 744 {
 745         size_t i;
 746         void *tmp;
 747
 748         for (i = 1; i < size; ++i) {
 749                 size_t child = i;
 750                 while (child > 0) {
 751                         size_t parent = (child - 1) / 2;
 752
 753                         if (array [parent] >= array [child])
 754                                 break;
 755
 756                         tmp = array [parent];
 757                         array [parent] = array [child];
 758                         array [child] = tmp;
 759
 760                         child = parent;
 761                 }
 762         }
 763
 764         for (i = size - 1; i > 0; --i) {
 765                 size_t end, root;
 766                 tmp = array [i];
 767                 array [i] = array [0];
 768                 array [0] = tmp;
 769
 770                 end = i - 1;
 771                 root = 0;
 772
 773                 while (root * 2 + 1 <= end) {
 774                         size_t child = root * 2 + 1;
 775
 776                         if (child < end && array [child] < array [child + 1])
 777                                 ++child;
 778                         if (array [root] >= array [child])
 779                                 break;
 780
 781                         tmp = array [root];
 782                         array [root] = array [child];
 783                         array [child] = tmp;
 784
 785                         root = child;
 786                 }
 787         }
 788 }
 789
 790 /*
 791  * Scan the memory between start and end and queue values which could be pointers
 792  * to the area between start_nursery and end_nursery for later consideration.
 793  * Typically used for thread stacks.
 794  */
 795 void
 796 sgen_conservatively_pin_objects_from (void **start, void **end, void *start_nursery, void *end_nursery, int pin_type)
 797 {
 798         int count = 0;
 799
 800         SGEN_ASSERT (0, ((mword)start & (SIZEOF_VOID_P - 1)) == 0, "Why are we scanning for references in unaligned memory ?");
 801
 802 #if defined(VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE) && !defined(_WIN64)
 803         VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE (start, (char*)end - (char*)start);
 804 #endif
 805
 806         while (start < end) {
 807                 /*
 808                  * *start can point to the middle of an object
 809                  * note: should we handle pointing at the end of an object?
 810                  * pinning in C# code disallows pointing at the end of an object
 811                  * but there is some small chance that an optimizing C compiler
 812                  * may keep the only reference to an object by pointing
 813                  * at the end of it. We ignore this small chance for now.
 814                  * Pointers to the end of an object are indistinguishable
 815                  * from pointers to the start of the next object in memory
 816                  * so if we allow that we'd need to pin two objects...
 817                  * We queue the pointer in an array, the
 818                  * array will then be sorted and uniqued. This way
 819                  * we can coalesce several pinning pointers and it should
 820                  * be faster since we'd do a memory scan with increasing
 821                  * addresses. Note: we can align the address to the allocation
 822                  * alignment, so the unique process is more effective.
 823                  */
 824                 mword addr = (mword)*start;
 825                 addr &= ~(ALLOC_ALIGN - 1);
 826                 if (addr >= (mword)start_nursery && addr < (mword)end_nursery) {
 827                         SGEN_LOG (6, "Pinning address %p from %p", (void*)addr, start);
 828                         sgen_pin_stage_ptr ((void*)addr);
 829                         binary_protocol_pin_stage (start, (void*)addr);
 830                         sgen_pin_stats_register_address ((char*)addr, pin_type);
 831                         count++;
 832                 }
 833                 start++;
 834         }
 835         if (count)
 836                 SGEN_LOG (7, "found %d potential pinned heap pointers", count);
 837 }
 838
 839 /*
 840  * The first thing we do in a collection is to identify pinned objects.
 841  * This function considers all the areas of memory that need to be
 842  * conservatively scanned.
 843  */
 844 static void
 845 pin_from_roots (void *start_nursery, void *end_nursery, ScanCopyContext ctx)
 846 {
 847         void **start_root;
 848         RootRecord *root;
 849         SGEN_LOG (2, "Scanning pinned roots (%d bytes, %d/%d entries)", (int)roots_size, roots_hash [ROOT_TYPE_NORMAL].num_entries, roots_hash [ROOT_TYPE_PINNED].num_entries);
 850         /* objects pinned from the API are inside these roots */
 851         SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_PINNED], void **, start_root, RootRecord *, root) {
 852                 SGEN_LOG (6, "Pinned roots %p-%p", start_root, root->end_root);
 853                 sgen_conservatively_pin_objects_from (start_root, (void**)root->end_root, start_nursery, end_nursery, PIN_TYPE_OTHER);
 854         } SGEN_HASH_TABLE_FOREACH_END;
 855         /* now deal with the thread stacks
 856          * in the future we should be able to conservatively scan only:
 857          * *) the cpu registers
 858          * *) the unmanaged stack frames
 859          * *) the _last_ managed stack frame
 860          * *) pointers slots in managed frames
 861          */
 862         sgen_client_scan_thread_data (start_nursery, end_nursery, FALSE, ctx);
 863 }
 864
 865 static void
 866 single_arg_user_copy_or_mark (GCObject **obj, void *gc_data)
 867 {
 868         ScanCopyContext *ctx = (ScanCopyContext *)gc_data;
 869         ctx->ops->copy_or_mark_object (obj, ctx->queue);
 870 }
 871
 872 /*
 873  * The memory area from start_root to end_root contains pointers to objects.
 874  * Their position is precisely described by @desc (this means that the pointer
 875  * can be either NULL or the pointer to the start of an object).
 876  * This functions copies them to to_space updates them.
 877  *
 878  * This function is not thread-safe!
 879  */
 880 static void
 881 precisely_scan_objects_from (void** start_root, void** end_root, char* n_start, char *n_end, SgenDescriptor desc, ScanCopyContext ctx)
 882 {
 883         CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object;
 884         ScanPtrFieldFunc scan_field_func = ctx.ops->scan_ptr_field;
 885         SgenGrayQueue *queue = ctx.queue;
 886
 887         switch (desc & ROOT_DESC_TYPE_MASK) {
 888         case ROOT_DESC_BITMAP:
 889                 desc >>= ROOT_DESC_TYPE_SHIFT;
 890                 while (desc) {
 891                         if ((desc & 1) && *start_root) {
 892                                 copy_func ((GCObject**)start_root, queue);
 893                                 SGEN_LOG (9, "Overwrote root at %p with %p", start_root, *start_root);
 894                         }
 895                         desc >>= 1;
 896                         start_root++;
 897                 }
 898                 return;
 899         case ROOT_DESC_COMPLEX: {
 900                 gsize *bitmap_data = (gsize *)sgen_get_complex_descriptor_bitmap (desc);
 901                 gsize bwords = (*bitmap_data) - 1;
 902                 void **start_run = start_root;
 903                 bitmap_data++;
 904                 while (bwords-- > 0) {
 905                         gsize bmap = *bitmap_data++;
 906                         void **objptr = start_run;
 907                         while (bmap) {
 908                                 if ((bmap & 1) && *objptr) {
 909                                         copy_func ((GCObject**)objptr, queue);
 910                                         SGEN_LOG (9, "Overwrote root at %p with %p", objptr, *objptr);
 911                                 }
 912                                 bmap >>= 1;
 913                                 ++objptr;
 914                         }
 915                         start_run += GC_BITS_PER_WORD;
 916                 }
 917                 break;
 918         }
 919         case ROOT_DESC_VECTOR: {
 920                 void **p;
 921
 922                 for (p = start_root; p < end_root; p++) {
 923                         if (*p)
 924                                 scan_field_func (NULL, (GCObject**)p, queue);
 925                 }
 926                 break;
 927         }
 928         case ROOT_DESC_USER: {
 929                 SgenUserRootMarkFunc marker = sgen_get_user_descriptor_func (desc);
 930                 marker (start_root, single_arg_user_copy_or_mark, &ctx);
 931                 break;
 932         }
 933         case ROOT_DESC_RUN_LEN:
 934                 g_assert_not_reached ();
 935         default:
 936                 g_assert_not_reached ();
 937         }
 938 }
 939
 940 static void
 941 reset_heap_boundaries (void)
 942 {
 943         lowest_heap_address = ~(mword)0;
 944         highest_heap_address = 0;
 945 }
 946
 947 void
 948 sgen_update_heap_boundaries (mword low, mword high)
 949 {
 950         mword old;
 951
 952         do {
 953                 old = lowest_heap_address;
 954                 if (low >= old)
 955                         break;
 956         } while (SGEN_CAS_PTR ((gpointer*)&lowest_heap_address, (gpointer)low, (gpointer)old) != (gpointer)old);
 957
 958         do {
 959                 old = highest_heap_address;
 960                 if (high <= old)
 961                         break;
 962         } while (SGEN_CAS_PTR ((gpointer*)&highest_heap_address, (gpointer)high, (gpointer)old) != (gpointer)old);
 963 }
 964
 965 /*
 966  * Allocate and setup the data structures needed to be able to allocate objects
 967  * in the nursery. The nursery is stored in nursery_section.
 968  */
 969 static void
 970 alloc_nursery (gboolean dynamic, size_t min_size, size_t max_size)
 971 {
 972         char *data;
 973         size_t scan_starts;
 974
 975         if (dynamic) {
 976                 if (!min_size)
 977                         min_size = SGEN_DEFAULT_NURSERY_MIN_SIZE;
 978                 if (!max_size)
 979                         max_size = SGEN_DEFAULT_NURSERY_MAX_SIZE;
 980         } else {
 981                 SGEN_ASSERT (0, min_size == max_size, "We can't have nursery ranges for static configuration.");
 982                 if (!min_size)
 983                         min_size = max_size = SGEN_DEFAULT_NURSERY_SIZE;
 984         }
 985
 986         SGEN_ASSERT (0, !nursery_section, "Why are we allocating the nursery twice?");
 987         SGEN_LOG (2, "Allocating nursery size: %zu, initial %zu", max_size, min_size);
 988
 989         /* FIXME: handle OOM */
 990         nursery_section = (GCMemSection *)sgen_alloc_internal (INTERNAL_MEM_SECTION);
 991
 992         /* If there isn't enough space even for the nursery we should simply abort. */
 993         g_assert (sgen_memgov_try_alloc_space (max_size, SPACE_NURSERY));
 994
 995         /*
 996          * The nursery section range represents the memory section where objects
 997          * can be found. This is used when iterating for objects in the nursery,
 998          * pinning etc. sgen_nursery_max_size represents the total allocated space
 999          * for the nursery. sgen_nursery_size represents the current size of the
1000          * nursery and it is used for allocation limits, heuristics etc. The
1001          * nursery section is not always identical to the current nursery size
1002          * because it can contain pinned objects from when the nursery was larger.
1003          *
1004          * sgen_nursery_size <= nursery_section size <= sgen_nursery_max_size
1005          */
1006         data = (char *)major_collector.alloc_heap (max_size, max_size);
1007         sgen_update_heap_boundaries ((mword)data, (mword)(data + max_size));
1008         nursery_section->data = data;
1009         nursery_section->end_data = data + min_size;
1010         scan_starts = (max_size + SCAN_START_SIZE - 1) / SCAN_START_SIZE;
1011         nursery_section->scan_starts = (char **)sgen_alloc_internal_dynamic (sizeof (char*) * scan_starts, INTERNAL_MEM_SCAN_STARTS, TRUE);
1012         nursery_section->num_scan_start = scan_starts;
1013
1014         sgen_nursery_allocator_set_nursery_bounds (data, min_size, max_size);
1015 }
1016
1017 FILE *
1018 mono_gc_get_logfile (void)
1019 {
1020         return gc_debug_file;
1021 }
1022
1023 void
1024 mono_gc_params_set (const char* options)
1025 {
1026         if (gc_params_options)
1027                 g_free (gc_params_options);
1028
1029         gc_params_options = g_strdup (options);
1030 }
1031
1032 void
1033 mono_gc_debug_set (const char* options)
1034 {
1035         if (gc_debug_options)
1036                 g_free (gc_debug_options);
1037
1038         gc_debug_options = g_strdup (options);
1039 }
1040
1041 static void
1042 scan_finalizer_entries (SgenPointerQueue *fin_queue, ScanCopyContext ctx)
1043 {
1044         CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object;
1045         SgenGrayQueue *queue = ctx.queue;
1046         size_t i;
1047
1048         for (i = 0; i < fin_queue->next_slot; ++i) {
1049                 GCObject *obj = (GCObject *)fin_queue->data [i];
1050                 if (!obj)
1051                         continue;
1052                 SGEN_LOG (5, "Scan of fin ready object: %p (%s)\n", obj, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (obj)));
1053                 copy_func ((GCObject**)&fin_queue->data [i], queue);
1054         }
1055 }
1056
1057 static const char*
1058 generation_name (int generation)
1059 {
1060         switch (generation) {
1061         case GENERATION_NURSERY: return "nursery";
1062         case GENERATION_OLD: return "old";
1063         default: g_assert_not_reached ();
1064         }
1065 }
1066
1067 const char*
1068 sgen_generation_name (int generation)
1069 {
1070         return generation_name (generation);
1071 }
1072
1073 static void
1074 finish_gray_stack (int generation, ScanCopyContext ctx)
1075 {
1076         TV_DECLARE (atv);
1077         TV_DECLARE (btv);
1078         int done_with_ephemerons, ephemeron_rounds = 0;
1079         char *start_addr = generation == GENERATION_NURSERY ? sgen_get_nursery_start () : NULL;
1080         char *end_addr = generation == GENERATION_NURSERY ? sgen_get_nursery_end () : (char*)-1;
1081         SgenGrayQueue *queue = ctx.queue;
1082
1083         binary_protocol_finish_gray_stack_start (sgen_timestamp (), generation);
1084         /*
1085          * We copied all the reachable objects. Now it's the time to copy
1086          * the objects that were not referenced by the roots, but by the copied objects.
1087          * we built a stack of objects pointed to by gray_start: they are
1088          * additional roots and we may add more items as we go.
1089          * We loop until gray_start == gray_objects which means no more objects have
1090          * been added. Note this is iterative: no recursion is involved.
1091          * We need to walk the LO list as well in search of marked big objects
1092          * (use a flag since this is needed only on major collections). We need to loop
1093          * here as well, so keep a counter of marked LO (increasing it in copy_object).
1094          *   To achieve better cache locality and cache usage, we drain the gray stack
1095          * frequently, after each object is copied, and just finish the work here.
1096          */
1097         sgen_drain_gray_stack (ctx);
1098         TV_GETTIME (atv);
1099         SGEN_LOG (2, "%s generation done", generation_name (generation));
1100
1101         /*
1102         Reset bridge data, we might have lingering data from a previous collection if this is a major
1103         collection trigged by minor overflow.
1104
1105         We must reset the gathered bridges since their original block might be evacuated due to major
1106         fragmentation in the meanwhile and the bridge code should not have to deal with that.
1107         */
1108         if (sgen_client_bridge_need_processing ())
1109                 sgen_client_bridge_reset_data ();
1110
1111         /*
1112          * Mark all strong toggleref objects. This must be done before we walk ephemerons or finalizers
1113          * to ensure they see the full set of live objects.
1114          */
1115         sgen_client_mark_togglerefs (start_addr, end_addr, ctx);
1116
1117         /*
1118          * Walk the ephemeron tables marking all values with reachable keys. This must be completely done
1119          * before processing finalizable objects and non-tracking weak links to avoid finalizing/clearing
1120          * objects that are in fact reachable.
1121          */
1122         done_with_ephemerons = 0;
1123         do {
1124                 done_with_ephemerons = sgen_client_mark_ephemerons (ctx);
1125                 sgen_drain_gray_stack (ctx);
1126                 ++ephemeron_rounds;
1127         } while (!done_with_ephemerons);
1128
1129         if (sgen_client_bridge_need_processing ()) {
1130                 /*Make sure the gray stack is empty before we process bridge objects so we get liveness right*/
1131                 sgen_drain_gray_stack (ctx);
1132                 sgen_collect_bridge_objects (generation, ctx);
1133                 if (generation == GENERATION_OLD)
1134                         sgen_collect_bridge_objects (GENERATION_NURSERY, ctx);
1135
1136                 /*
1137                 Do the first bridge step here, as the collector liveness state will become useless after that.
1138
1139                 An important optimization is to only proccess the possibly dead part of the object graph and skip
1140                 over all live objects as we transitively know everything they point must be alive too.
1141
1142                 The above invariant is completely wrong if we let the gray queue be drained and mark/copy everything.
1143
1144                 This has the unfortunate side effect of making overflow collections perform the first step twice, but
1145                 given we now have heuristics that perform major GC in anticipation of minor overflows this should not
1146                 be a big deal.
1147                 */
1148                 sgen_client_bridge_processing_stw_step ();
1149         }
1150
1151         /*
1152         Make sure we drain the gray stack before processing disappearing links and finalizers.
1153         If we don't make sure it is empty we might wrongly see a live object as dead.
1154         */
1155         sgen_drain_gray_stack (ctx);
1156
1157         /*
1158         We must clear weak links that don't track resurrection before processing object ready for
1159         finalization so they can be cleared before that.
1160         */
1161         sgen_null_link_in_range (generation, ctx, FALSE);
1162         if (generation == GENERATION_OLD)
1163                 sgen_null_link_in_range (GENERATION_NURSERY, ctx, FALSE);
1164
1165
1166         /* walk the finalization queue and move also the objects that need to be
1167          * finalized: use the finalized objects as new roots so the objects they depend
1168          * on are also not reclaimed. As with the roots above, only objects in the nursery
1169          * are marked/copied.
1170          */
1171         sgen_finalize_in_range (generation, ctx);
1172         if (generation == GENERATION_OLD)
1173                 sgen_finalize_in_range (GENERATION_NURSERY, ctx);
1174         /* drain the new stack that might have been created */
1175         SGEN_LOG (6, "Precise scan of gray area post fin");
1176         sgen_drain_gray_stack (ctx);
1177
1178         /*
1179          * This must be done again after processing finalizable objects since CWL slots are cleared only after the key is finalized.
1180          */
1181         done_with_ephemerons = 0;
1182         do {
1183                 done_with_ephemerons = sgen_client_mark_ephemerons (ctx);
1184                 sgen_drain_gray_stack (ctx);
1185                 ++ephemeron_rounds;
1186         } while (!done_with_ephemerons);
1187
1188         sgen_client_clear_unreachable_ephemerons (ctx);
1189
1190         /*
1191          * We clear togglerefs only after all possible chances of revival are done.
1192          * This is semantically more inline with what users expect and it allows for
1193          * user finalizers to correctly interact with TR objects.
1194         */
1195         sgen_client_clear_togglerefs (start_addr, end_addr, ctx);
1196
1197         TV_GETTIME (btv);
1198         SGEN_LOG (2, "Finalize queue handling scan for %s generation: %lld usecs %d ephemeron rounds", generation_name (generation), (long long)TV_ELAPSED (atv, btv), ephemeron_rounds);
1199
1200         /*
1201          * handle disappearing links
1202          * Note we do this after checking the finalization queue because if an object
1203          * survives (at least long enough to be finalized) we don't clear the link.
1204          * This also deals with a possible issue with the monitor reclamation: with the Boehm
1205          * GC a finalized object my lose the monitor because it is cleared before the finalizer is
1206          * called.
1207          */
1208         g_assert (sgen_gray_object_queue_is_empty (queue));
1209         for (;;) {
1210                 sgen_null_link_in_range (generation, ctx, TRUE);
1211                 if (generation == GENERATION_OLD)
1212                         sgen_null_link_in_range (GENERATION_NURSERY, ctx, TRUE);
1213                 if (sgen_gray_object_queue_is_empty (queue))
1214                         break;
1215                 sgen_drain_gray_stack (ctx);
1216         }
1217
1218         g_assert (sgen_gray_object_queue_is_empty (queue));
1219
1220         binary_protocol_finish_gray_stack_end (sgen_timestamp (), generation);
1221 }
1222
1223 void
1224 sgen_check_section_scan_starts (GCMemSection *section)
1225 {
1226         size_t i;
1227         for (i = 0; i < section->num_scan_start; ++i) {
1228                 if (section->scan_starts [i]) {
1229                         mword size = safe_object_get_size ((GCObject*) section->scan_starts [i]);
1230                         SGEN_ASSERT (0, size >= SGEN_CLIENT_MINIMUM_OBJECT_SIZE && size <= MAX_SMALL_OBJ_SIZE, "Weird object size at scan starts.");
1231                 }
1232         }
1233 }
1234
1235 static void
1236 check_scan_starts (void)
1237 {
1238         if (!do_scan_starts_check)
1239                 return;
1240         sgen_check_section_scan_starts (nursery_section);
1241         major_collector.check_scan_starts ();
1242 }
1243
1244 static void
1245 scan_from_registered_roots (char *addr_start, char *addr_end, int root_type, ScanCopyContext ctx)
1246 {
1247         void **start_root;
1248         RootRecord *root;
1249         SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], void **, start_root, RootRecord *, root) {
1250                 SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
1251                 precisely_scan_objects_from (start_root, (void**)root->end_root, addr_start, addr_end, root->root_desc, ctx);
1252         } SGEN_HASH_TABLE_FOREACH_END;
1253 }
1254
1255 static void
1256 init_stats (void)
1257 {
1258         static gboolean inited = FALSE;
1259
1260         if (inited)
1261                 return;
1262
1263         mono_counters_register ("Collection max time",  MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME | MONO_COUNTER_MONOTONIC, &time_max);
1264
1265         mono_counters_register ("Minor fragment clear", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_pre_collection_fragment_clear);
1266         mono_counters_register ("Minor pinning", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_pinning);
1267         mono_counters_register ("Minor scan remembered set", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_scan_remsets);
1268         mono_counters_register ("Minor scan major blocks", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_scan_major_blocks);
1269         mono_counters_register ("Minor scan los", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_scan_los);
1270         mono_counters_register ("Minor scan pinned", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_scan_pinned);
1271         mono_counters_register ("Minor scan roots", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_scan_roots);
1272         mono_counters_register ("Minor fragment creation", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_fragment_creation);
1273
1274         mono_counters_register ("Major fragment clear", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_pre_collection_fragment_clear);
1275         mono_counters_register ("Major pinning", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_pinning);
1276         mono_counters_register ("Major scan pinned", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_scan_pinned);
1277         mono_counters_register ("Major scan roots", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_scan_roots);
1278         mono_counters_register ("Major scan mod union blocks", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_scan_mod_union_blocks);
1279         mono_counters_register ("Major scan mod union los", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_scan_mod_union_los);
1280         mono_counters_register ("Major finish gray stack", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_finish_gray_stack);
1281         mono_counters_register ("Major free big objects", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_free_bigobjs);
1282         mono_counters_register ("Major LOS sweep", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_los_sweep);
1283         mono_counters_register ("Major sweep", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_sweep);
1284         mono_counters_register ("Major fragment creation", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_fragment_creation);
1285
1286         mono_counters_register ("Number of pinned objects", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_pinned_objects);
1287
1288 #ifdef HEAVY_STATISTICS
1289         mono_counters_register ("WBarrier remember pointer", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_wbarrier_add_to_global_remset);
1290         mono_counters_register ("WBarrier arrayref copy", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_wbarrier_arrayref_copy);
1291         mono_counters_register ("WBarrier generic store called", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_wbarrier_generic_store);
1292         mono_counters_register ("WBarrier generic atomic store called", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_wbarrier_generic_store_atomic);
1293         mono_counters_register ("WBarrier set root", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_wbarrier_set_root);
1294
1295         mono_counters_register ("# objects allocated degraded", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_objects_alloced_degraded);
1296         mono_counters_register ("bytes allocated degraded", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_bytes_alloced_degraded);
1297
1298         mono_counters_register ("# copy_object() called (nursery)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_copy_object_called_nursery);
1299         mono_counters_register ("# objects copied (nursery)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_objects_copied_nursery);
1300         mono_counters_register ("# copy_object() called (major)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_copy_object_called_major);
1301         mono_counters_register ("# objects copied (major)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_objects_copied_major);
1302
1303         mono_counters_register ("# scan_object() called (nursery)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_scan_object_called_nursery);
1304         mono_counters_register ("# scan_object() called (major)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_scan_object_called_major);
1305
1306         mono_counters_register ("Slots allocated in vain", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_slots_allocated_in_vain);
1307
1308         mono_counters_register ("# nursery copy_object() failed from space", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_nursery_copy_object_failed_from_space);
1309         mono_counters_register ("# nursery copy_object() failed forwarded", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_nursery_copy_object_failed_forwarded);
1310         mono_counters_register ("# nursery copy_object() failed pinned", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_nursery_copy_object_failed_pinned);
1311         mono_counters_register ("# nursery copy_object() failed to space", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_nursery_copy_object_failed_to_space);
1312
1313         sgen_nursery_allocator_init_heavy_stats ();
1314 #endif
1315
1316         inited = TRUE;
1317 }
1318
1319
1320 static void
1321 reset_pinned_from_failed_allocation (void)
1322 {
1323         bytes_pinned_from_failed_allocation = 0;
1324 }
1325
1326 void
1327 sgen_set_pinned_from_failed_allocation (mword objsize)
1328 {
1329         bytes_pinned_from_failed_allocation += objsize;
1330 }
1331
1332 gboolean
1333 sgen_collection_is_concurrent (void)
1334 {
1335         switch (current_collection_generation) {
1336         case GENERATION_NURSERY:
1337                 return FALSE;
1338         case GENERATION_OLD:
1339                 return concurrent_collection_in_progress;
1340         default:
1341                 g_error ("Invalid current generation %d", current_collection_generation);
1342         }
1343         return FALSE;
1344 }
1345
1346 gboolean
1347 sgen_concurrent_collection_in_progress (void)
1348 {
1349         return concurrent_collection_in_progress;
1350 }
1351
1352 typedef struct {
1353         SgenThreadPoolJob job;
1354         SgenObjectOperations *ops;
1355         SgenGrayQueue *gc_thread_gray_queue;
1356 } ScanJob;
1357
1358 typedef struct {
1359         ScanJob scan_job;
1360         int job_index, job_split_count;
1361         int data;
1362 } ParallelScanJob;
1363
1364 static ScanCopyContext
1365 scan_copy_context_for_scan_job (void *worker_data_untyped, ScanJob *job)
1366 {
1367         WorkerData *worker_data = (WorkerData *)worker_data_untyped;
1368
1369         if (!job->ops) {
1370                 /*
1371                  * For jobs enqueued on workers we set the ops at job runtime in order
1372                  * to be able to profit from on the fly optimized object ops or other
1373                  * object ops changes, like forced concurrent finish.
1374                  */
1375                 SGEN_ASSERT (0, sgen_workers_is_worker_thread (mono_native_thread_id_get ()), "We need a context for the scan job");
1376                 job->ops = sgen_workers_get_idle_func_object_ops (worker_data);
1377         }
1378
1379         return CONTEXT_FROM_OBJECT_OPERATIONS (job->ops, sgen_workers_get_job_gray_queue (worker_data, job->gc_thread_gray_queue));
1380 }
1381
1382 typedef struct {
1383         ScanJob scan_job;
1384         char *heap_start;
1385         char *heap_end;
1386         int root_type;
1387 } ScanFromRegisteredRootsJob;
1388
1389 static void
1390 job_scan_from_registered_roots (void *worker_data_untyped, SgenThreadPoolJob *job)
1391 {
1392         ScanFromRegisteredRootsJob *job_data = (ScanFromRegisteredRootsJob*)job;
1393         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, &job_data->scan_job);
1394
1395         scan_from_registered_roots (job_data->heap_start, job_data->heap_end, job_data->root_type, ctx);
1396 }
1397
1398 typedef struct {
1399         ScanJob scan_job;
1400         char *heap_start;
1401         char *heap_end;
1402 } ScanThreadDataJob;
1403
1404 static void
1405 job_scan_thread_data (void *worker_data_untyped, SgenThreadPoolJob *job)
1406 {
1407         ScanThreadDataJob *job_data = (ScanThreadDataJob*)job;
1408         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, &job_data->scan_job);
1409
1410         sgen_client_scan_thread_data (job_data->heap_start, job_data->heap_end, TRUE, ctx);
1411 }
1412
1413 typedef struct {
1414         ScanJob scan_job;
1415         SgenPointerQueue *queue;
1416 } ScanFinalizerEntriesJob;
1417
1418 static void
1419 job_scan_finalizer_entries (void *worker_data_untyped, SgenThreadPoolJob *job)
1420 {
1421         ScanFinalizerEntriesJob *job_data = (ScanFinalizerEntriesJob*)job;
1422         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, &job_data->scan_job);
1423
1424         scan_finalizer_entries (job_data->queue, ctx);
1425 }
1426
1427 static void
1428 job_scan_wbroots (void *worker_data_untyped, SgenThreadPoolJob *job)
1429 {
1430         ScanJob *job_data = (ScanJob*)job;
1431         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, job_data);
1432
1433         sgen_wbroots_scan_card_table (ctx);
1434 }
1435
1436 static void
1437 job_scan_major_card_table (void *worker_data_untyped, SgenThreadPoolJob *job)
1438 {
1439         SGEN_TV_DECLARE (atv);
1440         SGEN_TV_DECLARE (btv);
1441         ParallelScanJob *job_data = (ParallelScanJob*)job;
1442         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, (ScanJob*)job_data);
1443
1444         SGEN_TV_GETTIME (atv);
1445         major_collector.scan_card_table (CARDTABLE_SCAN_GLOBAL, ctx, job_data->job_index, job_data->job_split_count, job_data->data);
1446         SGEN_TV_GETTIME (btv);
1447         time_minor_scan_major_blocks += SGEN_TV_ELAPSED (atv, btv);
1448
1449         if (worker_data_untyped)
1450                 ((WorkerData*)worker_data_untyped)->major_scan_time += SGEN_TV_ELAPSED (atv, btv);
1451 }
1452
1453 static void
1454 job_scan_los_card_table (void *worker_data_untyped, SgenThreadPoolJob *job)
1455 {
1456         SGEN_TV_DECLARE (atv);
1457         SGEN_TV_DECLARE (btv);
1458         ParallelScanJob *job_data = (ParallelScanJob*)job;
1459         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, (ScanJob*)job_data);
1460
1461         SGEN_TV_GETTIME (atv);
1462         sgen_los_scan_card_table (CARDTABLE_SCAN_GLOBAL, ctx, job_data->job_index, job_data->job_split_count);
1463         SGEN_TV_GETTIME (btv);
1464         time_minor_scan_los += SGEN_TV_ELAPSED (atv, btv);
1465
1466         if (worker_data_untyped)
1467                 ((WorkerData*)worker_data_untyped)->los_scan_time += SGEN_TV_ELAPSED (atv, btv);
1468 }
1469
1470 static void
1471 job_scan_major_mod_union_card_table (void *worker_data_untyped, SgenThreadPoolJob *job)
1472 {
1473         SGEN_TV_DECLARE (atv);
1474         SGEN_TV_DECLARE (btv);
1475         ParallelScanJob *job_data = (ParallelScanJob*)job;
1476         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, (ScanJob*)job_data);
1477
1478         g_assert (concurrent_collection_in_progress);
1479         SGEN_TV_GETTIME (atv);
1480         major_collector.scan_card_table (CARDTABLE_SCAN_MOD_UNION, ctx, job_data->job_index, job_data->job_split_count, job_data->data);
1481         SGEN_TV_GETTIME (btv);
1482         time_major_scan_mod_union_blocks += SGEN_TV_ELAPSED (atv, btv);
1483
1484         if (worker_data_untyped)
1485                 ((WorkerData*)worker_data_untyped)->major_scan_time += SGEN_TV_ELAPSED (atv, btv);
1486 }
1487
1488 static void
1489 job_scan_los_mod_union_card_table (void *worker_data_untyped, SgenThreadPoolJob *job)
1490 {
1491         SGEN_TV_DECLARE (atv);
1492         SGEN_TV_DECLARE (btv);
1493         ParallelScanJob *job_data = (ParallelScanJob*)job;
1494         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, (ScanJob*)job_data);
1495
1496         g_assert (concurrent_collection_in_progress);
1497         SGEN_TV_GETTIME (atv);
1498         sgen_los_scan_card_table (CARDTABLE_SCAN_MOD_UNION, ctx, job_data->job_index, job_data->job_split_count);
1499         SGEN_TV_GETTIME (btv);
1500         time_major_scan_mod_union_los += SGEN_TV_ELAPSED (atv, btv);
1501
1502         if (worker_data_untyped)
1503                 ((WorkerData*)worker_data_untyped)->los_scan_time += SGEN_TV_ELAPSED (atv, btv);
1504 }
1505
1506 static void
1507 job_major_mod_union_preclean (void *worker_data_untyped, SgenThreadPoolJob *job)
1508 {
1509         SGEN_TV_DECLARE (atv);
1510         SGEN_TV_DECLARE (btv);
1511         ParallelScanJob *job_data = (ParallelScanJob*)job;
1512         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, (ScanJob*)job_data);
1513
1514         g_assert (concurrent_collection_in_progress);
1515         SGEN_TV_GETTIME (atv);
1516         major_collector.scan_card_table (CARDTABLE_SCAN_MOD_UNION_PRECLEAN, ctx, job_data->job_index, job_data->job_split_count, job_data->data);
1517         SGEN_TV_GETTIME (btv);
1518
1519         g_assert (worker_data_untyped);
1520         ((WorkerData*)worker_data_untyped)->major_scan_time += SGEN_TV_ELAPSED (atv, btv);
1521 }
1522
1523 static void
1524 job_los_mod_union_preclean (void *worker_data_untyped, SgenThreadPoolJob *job)
1525 {
1526         SGEN_TV_DECLARE (atv);
1527         SGEN_TV_DECLARE (btv);
1528         ParallelScanJob *job_data = (ParallelScanJob*)job;
1529         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, (ScanJob*)job_data);
1530
1531         g_assert (concurrent_collection_in_progress);
1532         SGEN_TV_GETTIME (atv);
1533         sgen_los_scan_card_table (CARDTABLE_SCAN_MOD_UNION_PRECLEAN, ctx, job_data->job_index, job_data->job_split_count);
1534         SGEN_TV_GETTIME (btv);
1535
1536         g_assert (worker_data_untyped);
1537         ((WorkerData*)worker_data_untyped)->los_scan_time += SGEN_TV_ELAPSED (atv, btv);
1538 }
1539
1540 static void
1541 job_scan_last_pinned (void *worker_data_untyped, SgenThreadPoolJob *job)
1542 {
1543         ScanJob *job_data = (ScanJob*)job;
1544         ScanCopyContext ctx = scan_copy_context_for_scan_job (worker_data_untyped, job_data);
1545
1546         g_assert (concurrent_collection_in_progress);
1547
1548         sgen_scan_pin_queue_objects (ctx);
1549 }
1550
1551 static void
1552 workers_finish_callback (void)
1553 {
1554         ParallelScanJob *psj;
1555         ScanJob *sj;
1556         size_t num_major_sections = major_collector.get_num_major_sections ();
1557         int split_count = sgen_workers_get_job_split_count (GENERATION_OLD);
1558         int i;
1559         /* Mod union preclean jobs */
1560         for (i = 0; i < split_count; i++) {
1561                 psj = (ParallelScanJob*)sgen_thread_pool_job_alloc ("preclean major mod union cardtable", job_major_mod_union_preclean, sizeof (ParallelScanJob));
1562                 psj->scan_job.gc_thread_gray_queue = NULL;
1563                 psj->job_index = i;
1564                 psj->job_split_count = split_count;
1565                 psj->data = num_major_sections / split_count;
1566                 sgen_workers_enqueue_job (GENERATION_OLD, &psj->scan_job.job, TRUE);
1567         }
1568
1569         for (i = 0; i < split_count; i++) {
1570                 psj = (ParallelScanJob*)sgen_thread_pool_job_alloc ("preclean los mod union cardtable", job_los_mod_union_preclean, sizeof (ParallelScanJob));
1571                 psj->scan_job.gc_thread_gray_queue = NULL;
1572                 psj->job_index = i;
1573                 psj->job_split_count = split_count;
1574                 sgen_workers_enqueue_job (GENERATION_OLD, &psj->scan_job.job, TRUE);
1575         }
1576
1577         sj = (ScanJob*)sgen_thread_pool_job_alloc ("scan last pinned", job_scan_last_pinned, sizeof (ScanJob));
1578         sj->gc_thread_gray_queue = NULL;
1579         sgen_workers_enqueue_job (GENERATION_OLD, &sj->job, TRUE);
1580 }
1581
1582 static void
1583 init_gray_queue (SgenGrayQueue *gc_thread_gray_queue)
1584 {
1585         sgen_gray_object_queue_init (gc_thread_gray_queue, NULL, TRUE);
1586 }
1587
1588 static void
1589 enqueue_scan_remembered_set_jobs (SgenGrayQueue *gc_thread_gray_queue, SgenObjectOperations *ops, gboolean enqueue)
1590 {
1591         int i, split_count = sgen_workers_get_job_split_count (GENERATION_NURSERY);
1592         size_t num_major_sections = major_collector.get_num_major_sections ();
1593         ScanJob *sj;
1594
1595         sj = (ScanJob*)sgen_thread_pool_job_alloc ("scan wbroots", job_scan_wbroots, sizeof (ScanJob));
1596         sj->ops = ops;
1597         sj->gc_thread_gray_queue = gc_thread_gray_queue;
1598         sgen_workers_enqueue_job (GENERATION_NURSERY, &sj->job, enqueue);
1599
1600         for (i = 0; i < split_count; i++) {
1601                 ParallelScanJob *psj;
1602
1603                 psj = (ParallelScanJob*)sgen_thread_pool_job_alloc ("scan major remsets", job_scan_major_card_table, sizeof (ParallelScanJob));
1604                 psj->scan_job.ops = ops;
1605                 psj->scan_job.gc_thread_gray_queue = gc_thread_gray_queue;
1606                 psj->job_index = i;
1607                 psj->job_split_count = split_count;
1608                 psj->data = num_major_sections / split_count;
1609                 sgen_workers_enqueue_job (GENERATION_NURSERY, &psj->scan_job.job, enqueue);
1610
1611                 psj = (ParallelScanJob*)sgen_thread_pool_job_alloc ("scan LOS remsets", job_scan_los_card_table, sizeof (ParallelScanJob));
1612                 psj->scan_job.ops = ops;
1613                 psj->scan_job.gc_thread_gray_queue = gc_thread_gray_queue;
1614                 psj->job_index = i;
1615                 psj->job_split_count = split_count;
1616                 sgen_workers_enqueue_job (GENERATION_NURSERY, &psj->scan_job.job, enqueue);
1617         }
1618 }
1619
1620 static void
1621 enqueue_scan_from_roots_jobs (SgenGrayQueue *gc_thread_gray_queue, char *heap_start, char *heap_end, SgenObjectOperations *ops, gboolean enqueue)
1622 {
1623         ScanFromRegisteredRootsJob *scrrj;
1624         ScanThreadDataJob *stdj;
1625         ScanFinalizerEntriesJob *sfej;
1626
1627         /* registered roots, this includes static fields */
1628
1629         scrrj = (ScanFromRegisteredRootsJob*)sgen_thread_pool_job_alloc ("scan from registered roots normal", job_scan_from_registered_roots, sizeof (ScanFromRegisteredRootsJob));
1630         scrrj->scan_job.ops = ops;
1631         scrrj->scan_job.gc_thread_gray_queue = gc_thread_gray_queue;
1632         scrrj->heap_start = heap_start;
1633         scrrj->heap_end = heap_end;
1634         scrrj->root_type = ROOT_TYPE_NORMAL;
1635         sgen_workers_enqueue_job (current_collection_generation, &scrrj->scan_job.job, enqueue);
1636
1637         if (current_collection_generation == GENERATION_OLD) {
1638                 /* During minors we scan the cardtable for these roots instead */
1639                 scrrj = (ScanFromRegisteredRootsJob*)sgen_thread_pool_job_alloc ("scan from registered roots wbarrier", job_scan_from_registered_roots, sizeof (ScanFromRegisteredRootsJob));
1640                 scrrj->scan_job.ops = ops;
1641                 scrrj->scan_job.gc_thread_gray_queue = gc_thread_gray_queue;
1642                 scrrj->heap_start = heap_start;
1643                 scrrj->heap_end = heap_end;
1644                 scrrj->root_type = ROOT_TYPE_WBARRIER;
1645                 sgen_workers_enqueue_job (current_collection_generation, &scrrj->scan_job.job, enqueue);
1646         }
1647
1648         /* Threads */
1649
1650         stdj = (ScanThreadDataJob*)sgen_thread_pool_job_alloc ("scan thread data", job_scan_thread_data, sizeof (ScanThreadDataJob));
1651         stdj->scan_job.ops = ops;
1652         stdj->scan_job.gc_thread_gray_queue = gc_thread_gray_queue;
1653         stdj->heap_start = heap_start;
1654         stdj->heap_end = heap_end;
1655         sgen_workers_enqueue_job (current_collection_generation, &stdj->scan_job.job, enqueue);
1656
1657         /* Scan the list of objects ready for finalization. */
1658
1659         sfej = (ScanFinalizerEntriesJob*)sgen_thread_pool_job_alloc ("scan finalizer entries", job_scan_finalizer_entries, sizeof (ScanFinalizerEntriesJob));
1660         sfej->scan_job.ops = ops;
1661         sfej->scan_job.gc_thread_gray_queue = gc_thread_gray_queue;
1662         sfej->queue = &fin_ready_queue;
1663         sgen_workers_enqueue_job (current_collection_generation, &sfej->scan_job.job, enqueue);
1664
1665         sfej = (ScanFinalizerEntriesJob*)sgen_thread_pool_job_alloc ("scan critical finalizer entries", job_scan_finalizer_entries, sizeof (ScanFinalizerEntriesJob));
1666         sfej->scan_job.ops = ops;
1667         sfej->scan_job.gc_thread_gray_queue = gc_thread_gray_queue;
1668         sfej->queue = &critical_fin_queue;
1669         sgen_workers_enqueue_job (current_collection_generation, &sfej->scan_job.job, enqueue);
1670 }
1671
1672 /*
1673  * Perform a nursery collection.
1674  *
1675  * Return whether any objects were late-pinned due to being out of memory.
1676  */
1677 static gboolean
1678 collect_nursery (const char *reason, gboolean is_overflow, SgenGrayQueue *unpin_queue)
1679 {
1680         gboolean needs_major, is_parallel = FALSE;
1681         mword fragment_total;
1682         SgenGrayQueue gc_thread_gray_queue;
1683         SgenObjectOperations *object_ops_nopar, *object_ops_par = NULL;
1684         ScanCopyContext ctx;
1685         TV_DECLARE (atv);
1686         TV_DECLARE (btv);
1687         SGEN_TV_DECLARE (last_minor_collection_start_tv);
1688         SGEN_TV_DECLARE (last_minor_collection_end_tv);
1689         guint64 major_scan_start = time_minor_scan_major_blocks;
1690         guint64 los_scan_start = time_minor_scan_los;
1691         guint64 finish_gray_start = time_minor_finish_gray_stack;
1692
1693         if (disable_minor_collections)
1694                 return TRUE;
1695
1696         TV_GETTIME (last_minor_collection_start_tv);
1697         atv = last_minor_collection_start_tv;
1698
1699         binary_protocol_collection_begin (InterlockedRead (&gc_stats.minor_gc_count), GENERATION_NURSERY);
1700
1701         object_ops_nopar = sgen_concurrent_collection_in_progress ()
1702                                 ? &sgen_minor_collector.serial_ops_with_concurrent_major
1703                                 : &sgen_minor_collector.serial_ops;
1704         if (sgen_minor_collector.is_parallel && sgen_nursery_size >= SGEN_PARALLEL_MINOR_MIN_NURSERY_SIZE) {
1705                 object_ops_par = sgen_concurrent_collection_in_progress ()
1706                                         ? &sgen_minor_collector.parallel_ops_with_concurrent_major
1707                                         : &sgen_minor_collector.parallel_ops;
1708                 is_parallel = TRUE;
1709         }
1710
1711         if (do_verify_nursery || do_dump_nursery_content)
1712                 sgen_debug_verify_nursery (do_dump_nursery_content);
1713
1714         current_collection_generation = GENERATION_NURSERY;
1715
1716         SGEN_ASSERT (0, !sgen_collection_is_concurrent (), "Why is the nursery collection concurrent?");
1717
1718         reset_pinned_from_failed_allocation ();
1719
1720         check_scan_starts ();
1721
1722         sgen_nursery_alloc_prepare_for_minor ();
1723
1724         degraded_mode = 0;
1725         objects_pinned = 0;
1726
1727         SGEN_LOG (1, "Start nursery collection %" G_GINT32_FORMAT " %p-%p, size: %d", InterlockedRead (&gc_stats.minor_gc_count), nursery_section->data, nursery_section->end_data, (int)(nursery_section->end_data - nursery_section->data));
1728
1729         /* world must be stopped already */
1730         TV_GETTIME (btv);
1731         time_minor_pre_collection_fragment_clear += TV_ELAPSED (atv, btv);
1732
1733         sgen_client_pre_collection_checks ();
1734
1735         major_collector.start_nursery_collection ();
1736
1737         sgen_memgov_minor_collection_start ();
1738
1739         init_gray_queue (&gc_thread_gray_queue);
1740         ctx = CONTEXT_FROM_OBJECT_OPERATIONS (object_ops_nopar, &gc_thread_gray_queue);
1741
1742         InterlockedIncrement (&gc_stats.minor_gc_count);
1743
1744         sgen_process_fin_stage_entries ();
1745
1746         /* pin from pinned handles */
1747         sgen_init_pinning ();
1748         if (concurrent_collection_in_progress)
1749                 sgen_init_pinning_for_conc ();
1750         sgen_client_binary_protocol_mark_start (GENERATION_NURSERY);
1751         pin_from_roots (nursery_section->data, nursery_section->end_data, ctx);
1752         /* pin cemented objects */
1753         sgen_pin_cemented_objects ();
1754         /* identify pinned objects */
1755         sgen_optimize_pin_queue ();
1756         sgen_pinning_setup_section (nursery_section);
1757
1758         pin_objects_in_nursery (FALSE, ctx);
1759         sgen_pinning_trim_queue_to_section (nursery_section);
1760         if (concurrent_collection_in_progress)
1761                 sgen_finish_pinning_for_conc ();
1762
1763         if (remset_consistency_checks)
1764                 sgen_check_remset_consistency ();
1765
1766         if (whole_heap_check_before_collection) {
1767                 sgen_clear_nursery_fragments ();
1768                 sgen_check_whole_heap (FALSE);
1769         }
1770
1771         TV_GETTIME (atv);
1772         time_minor_pinning += TV_ELAPSED (btv, atv);
1773         SGEN_LOG (2, "Finding pinned pointers: %zd in %lld usecs", sgen_get_pinned_count (), (long long)TV_ELAPSED (btv, atv));
1774         SGEN_LOG (4, "Start scan with %zd pinned objects", sgen_get_pinned_count ());
1775
1776         remset.start_scan_remsets ();
1777
1778         enqueue_scan_remembered_set_jobs (&gc_thread_gray_queue, is_parallel ? NULL : object_ops_nopar, is_parallel);
1779
1780         /* we don't have complete write barrier yet, so we scan all the old generation sections */
1781         TV_GETTIME (btv);
1782         time_minor_scan_remsets += TV_ELAPSED (atv, btv);
1783         SGEN_LOG (2, "Old generation scan: %lld usecs", (long long)TV_ELAPSED (atv, btv));
1784
1785         sgen_pin_stats_report ();
1786
1787         /* FIXME: Why do we do this at this specific, seemingly random, point? */
1788         sgen_client_collecting_minor (&fin_ready_queue, &critical_fin_queue);
1789
1790         TV_GETTIME (atv);
1791         time_minor_scan_pinned += TV_ELAPSED (btv, atv);
1792
1793         enqueue_scan_from_roots_jobs (&gc_thread_gray_queue, nursery_section->data, nursery_section->end_data, is_parallel ? NULL : object_ops_nopar, is_parallel);
1794
1795         if (is_parallel) {
1796                 gray_queue_redirect (&gc_thread_gray_queue);
1797                 sgen_workers_start_all_workers (GENERATION_NURSERY, object_ops_nopar, object_ops_par, NULL);
1798                 sgen_workers_join (GENERATION_NURSERY);
1799         }
1800
1801         TV_GETTIME (btv);
1802         time_minor_scan_roots += TV_ELAPSED (atv, btv);
1803
1804         finish_gray_stack (GENERATION_NURSERY, ctx);
1805
1806         TV_GETTIME (atv);
1807         time_minor_finish_gray_stack += TV_ELAPSED (btv, atv);
1808         sgen_client_binary_protocol_mark_end (GENERATION_NURSERY);
1809
1810         if (objects_pinned) {
1811                 sgen_optimize_pin_queue ();
1812                 sgen_pinning_setup_section (nursery_section);
1813         }
1814
1815         /*
1816          * This is the latest point at which we can do this check, because
1817          * sgen_build_nursery_fragments() unpins nursery objects again.
1818          */
1819         if (remset_consistency_checks)
1820                 sgen_check_remset_consistency ();
1821
1822
1823         if (sgen_max_pause_time) {
1824                 int duration;
1825
1826                 TV_GETTIME (btv);
1827                 duration = (int)(TV_ELAPSED (last_minor_collection_start_tv, btv) / 10000);
1828                 if (duration > (sgen_max_pause_time * sgen_max_pause_margin))
1829                         sgen_resize_nursery (TRUE);
1830                 else
1831                         sgen_resize_nursery (FALSE);
1832         } else {
1833                         sgen_resize_nursery (FALSE);
1834         }
1835
1836         /* walk the pin_queue, build up the fragment list of free memory, unmark
1837          * pinned objects as we go, memzero() the empty fragments so they are ready for the
1838          * next allocations.
1839          */
1840         sgen_client_binary_protocol_reclaim_start (GENERATION_NURSERY);
1841         fragment_total = sgen_build_nursery_fragments (nursery_section, unpin_queue);
1842         if (!fragment_total)
1843                 degraded_mode = 1;
1844
1845         /* Clear TLABs for all threads */
1846         sgen_clear_tlabs ();
1847
1848         sgen_client_binary_protocol_reclaim_end (GENERATION_NURSERY);
1849         TV_GETTIME (btv);
1850         time_minor_fragment_creation += TV_ELAPSED (atv, btv);
1851         SGEN_LOG (2, "Fragment creation: %lld usecs, %lu bytes available", (long long)TV_ELAPSED (atv, btv), (unsigned long)fragment_total);
1852
1853         if (remset_consistency_checks)
1854                 sgen_check_major_refs ();
1855
1856         major_collector.finish_nursery_collection ();
1857
1858         TV_GETTIME (last_minor_collection_end_tv);
1859         UnlockedAdd64 (&gc_stats.minor_gc_time, TV_ELAPSED (last_minor_collection_start_tv, last_minor_collection_end_tv));
1860
1861         sgen_debug_dump_heap ("minor", InterlockedRead (&gc_stats.minor_gc_count) - 1, NULL);
1862
1863         /* prepare the pin queue for the next collection */
1864         sgen_finish_pinning ();
1865         if (sgen_have_pending_finalizers ()) {
1866                 SGEN_LOG (4, "Finalizer-thread wakeup");
1867                 sgen_client_finalize_notify ();
1868         }
1869         sgen_pin_stats_reset ();
1870         /* clear cemented hash */
1871         sgen_cement_clear_below_threshold ();
1872
1873         sgen_gray_object_queue_dispose (&gc_thread_gray_queue);
1874
1875         check_scan_starts ();
1876
1877         binary_protocol_flush_buffers (FALSE);
1878
1879         sgen_memgov_minor_collection_end (reason, is_overflow);
1880
1881         /*objects are late pinned because of lack of memory, so a major is a good call*/
1882         needs_major = objects_pinned > 0;
1883         current_collection_generation = -1;
1884         objects_pinned = 0;
1885
1886         if (is_parallel)
1887                 binary_protocol_collection_end_stats (0, 0, time_minor_finish_gray_stack - finish_gray_start);
1888         else
1889                 binary_protocol_collection_end_stats (
1890                         time_minor_scan_major_blocks - major_scan_start,
1891                         time_minor_scan_los - los_scan_start,
1892                         time_minor_finish_gray_stack - finish_gray_start);
1893
1894         binary_protocol_collection_end (InterlockedRead (&gc_stats.minor_gc_count) - 1, GENERATION_NURSERY, 0, 0);
1895
1896         if (check_nursery_objects_pinned && !sgen_minor_collector.is_split)
1897                 sgen_check_nursery_objects_pinned (unpin_queue != NULL);
1898
1899         return needs_major;
1900 }
1901
1902 typedef enum {
1903         COPY_OR_MARK_FROM_ROOTS_SERIAL,
1904         COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT,
1905         COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT
1906 } CopyOrMarkFromRootsMode;
1907
1908 static void
1909 major_copy_or_mark_from_roots (SgenGrayQueue *gc_thread_gray_queue, size_t *old_next_pin_slot, CopyOrMarkFromRootsMode mode, SgenObjectOperations *object_ops_nopar, SgenObjectOperations *object_ops_par)
1910 {
1911         LOSObject *bigobj;
1912         TV_DECLARE (atv);
1913         TV_DECLARE (btv);
1914         /* FIXME: only use these values for the precise scan
1915          * note that to_space pointers should be excluded anyway...
1916          */
1917         char *heap_start = NULL;
1918         char *heap_end = (char*)-1;
1919         ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (object_ops_nopar, gc_thread_gray_queue);
1920         gboolean concurrent = mode != COPY_OR_MARK_FROM_ROOTS_SERIAL;
1921
1922         SGEN_ASSERT (0, !!concurrent == !!concurrent_collection_in_progress, "We've been called with the wrong mode.");
1923
1924         if (mode == COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT) {
1925                 /*This cleans up unused fragments */
1926                 sgen_nursery_allocator_prepare_for_pinning ();
1927
1928                 if (do_concurrent_checks)
1929                         sgen_debug_check_nursery_is_clean ();
1930         } else {
1931                 /* The concurrent collector doesn't touch the nursery. */
1932                 sgen_nursery_alloc_prepare_for_major ();
1933         }
1934
1935         TV_GETTIME (atv);
1936
1937         /* Pinning depends on this */
1938         sgen_clear_nursery_fragments ();
1939
1940         if (whole_heap_check_before_collection)
1941                 sgen_check_whole_heap (TRUE);
1942
1943         TV_GETTIME (btv);
1944         time_major_pre_collection_fragment_clear += TV_ELAPSED (atv, btv);
1945
1946         objects_pinned = 0;
1947
1948         sgen_client_pre_collection_checks ();
1949
1950         if (mode != COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT) {
1951                 /* Remsets are not useful for a major collection */
1952                 remset.clear_cards ();
1953         }
1954
1955         sgen_process_fin_stage_entries ();
1956
1957         TV_GETTIME (atv);
1958         sgen_init_pinning ();
1959         if (mode == COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT)
1960                 sgen_init_pinning_for_conc ();
1961         SGEN_LOG (6, "Collecting pinned addresses");
1962         pin_from_roots ((void*)lowest_heap_address, (void*)highest_heap_address, ctx);
1963         if (mode == COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT) {
1964                 /* Pin cemented objects that were forced */
1965                 sgen_pin_cemented_objects ();
1966         }
1967         sgen_optimize_pin_queue ();
1968         if (mode == COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT) {
1969                 /*
1970                  * Cemented objects that are in the pinned list will be marked. When
1971                  * marking concurrently we won't mark mod-union cards for these objects.
1972                  * Instead they will remain cemented until the next major collection,
1973                  * when we will recheck if they are still pinned in the roots.
1974                  */
1975                 sgen_cement_force_pinned ();
1976         }
1977
1978         sgen_client_collecting_major_1 ();
1979
1980         /*
1981          * pin_queue now contains all candidate pointers, sorted and
1982          * uniqued.  We must do two passes now to figure out which
1983          * objects are pinned.
1984          *
1985          * The first is to find within the pin_queue the area for each
1986          * section.  This requires that the pin_queue be sorted.  We
1987          * also process the LOS objects and pinned chunks here.
1988          *
1989          * The second, destructive, pass is to reduce the section
1990          * areas to pointers to the actually pinned objects.
1991          */
1992         SGEN_LOG (6, "Pinning from sections");
1993         /* first pass for the sections */
1994         sgen_find_section_pin_queue_start_end (nursery_section);
1995         /* identify possible pointers to the insize of large objects */
1996         SGEN_LOG (6, "Pinning from large objects");
1997         for (bigobj = los_object_list; bigobj; bigobj = bigobj->next) {
1998                 size_t dummy;
1999                 if (sgen_find_optimized_pin_queue_area ((char*)bigobj->data, (char*)bigobj->data + sgen_los_object_size (bigobj), &dummy, &dummy)) {
2000                         binary_protocol_pin (bigobj->data, (gpointer)LOAD_VTABLE (bigobj->data), safe_object_get_size (bigobj->data));
2001
2002                         if (sgen_los_object_is_pinned (bigobj->data)) {
2003                                 SGEN_ASSERT (0, mode == COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT, "LOS objects can only be pinned here after concurrent marking.");
2004                                 continue;
2005                         }
2006                         sgen_los_pin_object (bigobj->data);
2007                         if (SGEN_OBJECT_HAS_REFERENCES (bigobj->data))
2008                                 GRAY_OBJECT_ENQUEUE_SERIAL (gc_thread_gray_queue, bigobj->data, sgen_obj_get_descriptor ((GCObject*)bigobj->data));
2009                         sgen_pin_stats_register_object (bigobj->data, GENERATION_OLD);
2010                         SGEN_LOG (6, "Marked large object %p (%s) size: %lu from roots", bigobj->data,
2011                                         sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (bigobj->data)),
2012                                         (unsigned long)sgen_los_object_size (bigobj));
2013
2014                         sgen_client_pinned_los_object (bigobj->data);
2015                 }
2016         }
2017
2018         pin_objects_in_nursery (mode == COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT, ctx);
2019         if (check_nursery_objects_pinned && !sgen_minor_collector.is_split)
2020                 sgen_check_nursery_objects_pinned (mode != COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT);
2021
2022         major_collector.pin_objects (gc_thread_gray_queue);
2023         if (old_next_pin_slot)
2024                 *old_next_pin_slot = sgen_get_pinned_count ();
2025
2026         TV_GETTIME (btv);
2027         time_major_pinning += TV_ELAPSED (atv, btv);
2028         SGEN_LOG (2, "Finding pinned pointers: %zd in %lld usecs", sgen_get_pinned_count (), (long long)TV_ELAPSED (atv, btv));
2029         SGEN_LOG (4, "Start scan with %zd pinned objects", sgen_get_pinned_count ());
2030
2031         if (mode == COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT)
2032                 sgen_finish_pinning_for_conc ();
2033
2034         major_collector.init_to_space ();
2035
2036         SGEN_ASSERT (0, sgen_workers_all_done (), "Why are the workers not done when we start or finish a major collection?");
2037         if (mode == COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT) {
2038                 if (object_ops_par != NULL)
2039                         sgen_workers_set_num_active_workers (GENERATION_OLD, 0);
2040                 if (object_ops_par == NULL && sgen_workers_have_idle_work (GENERATION_OLD)) {
2041                         /*
2042                          * We force the finish of the worker with the new object ops context
2043                          * which can also do copying. We need to have finished pinning. On the
2044                          * parallel collector, there is no need to drain the private queues
2045                          * here, since we can do it as part of the finishing work, achieving
2046                          * better work distribution.
2047                          */
2048                         sgen_workers_start_all_workers (GENERATION_OLD, object_ops_nopar, object_ops_par, NULL);
2049
2050                         sgen_workers_join (GENERATION_OLD);
2051                 }
2052         }
2053
2054 #ifdef SGEN_DEBUG_INTERNAL_ALLOC
2055         main_gc_thread = mono_native_thread_self ();
2056 #endif
2057
2058         sgen_client_collecting_major_2 ();
2059
2060         TV_GETTIME (atv);
2061         time_major_scan_pinned += TV_ELAPSED (btv, atv);
2062
2063         sgen_client_collecting_major_3 (&fin_ready_queue, &critical_fin_queue);
2064
2065         enqueue_scan_from_roots_jobs (gc_thread_gray_queue, heap_start, heap_end, object_ops_nopar, FALSE);
2066
2067         TV_GETTIME (btv);
2068         time_major_scan_roots += TV_ELAPSED (atv, btv);
2069
2070         /*
2071          * We start the concurrent worker after pinning and after we scanned the roots
2072          * in order to make sure that the worker does not finish before handling all
2073          * the roots.
2074          */
2075         if (mode == COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT) {
2076                 sgen_workers_set_num_active_workers (GENERATION_OLD, 1);
2077                 gray_queue_redirect (gc_thread_gray_queue);
2078                 if (precleaning_enabled) {
2079                         sgen_workers_start_all_workers (GENERATION_OLD, object_ops_nopar, object_ops_par, workers_finish_callback);
2080                 } else {
2081                         sgen_workers_start_all_workers (GENERATION_OLD, object_ops_nopar, object_ops_par, NULL);
2082                 }
2083         }
2084
2085         if (mode == COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT) {
2086                 int i, split_count = sgen_workers_get_job_split_count (GENERATION_OLD);
2087                 size_t num_major_sections = major_collector.get_num_major_sections ();
2088                 gboolean parallel = object_ops_par != NULL;
2089
2090                 /* If we're not parallel we finish the collection on the gc thread */
2091                 if (parallel)
2092                         gray_queue_redirect (gc_thread_gray_queue);
2093
2094                 /* Mod union card table */
2095                 for (i = 0; i < split_count; i++) {
2096                         ParallelScanJob *psj;
2097
2098                         psj = (ParallelScanJob*)sgen_thread_pool_job_alloc ("scan mod union cardtable", job_scan_major_mod_union_card_table, sizeof (ParallelScanJob));
2099                         psj->scan_job.ops = parallel ? NULL : object_ops_nopar;
2100                         psj->scan_job.gc_thread_gray_queue = gc_thread_gray_queue;
2101                         psj->job_index = i;
2102                         psj->job_split_count = split_count;
2103                         psj->data = num_major_sections / split_count;
2104                         sgen_workers_enqueue_job (GENERATION_OLD, &psj->scan_job.job, parallel);
2105
2106                         psj = (ParallelScanJob*)sgen_thread_pool_job_alloc ("scan LOS mod union cardtable", job_scan_los_mod_union_card_table, sizeof (ParallelScanJob));
2107                         psj->scan_job.ops = parallel ? NULL : object_ops_nopar;
2108                         psj->scan_job.gc_thread_gray_queue = gc_thread_gray_queue;
2109                         psj->job_index = i;
2110                         psj->job_split_count = split_count;
2111                         sgen_workers_enqueue_job (GENERATION_OLD, &psj->scan_job.job, parallel);
2112                 }
2113
2114                 if (parallel) {
2115                         /*
2116                          * If we enqueue a job while workers are running we need to sgen_workers_ensure_awake
2117                          * in order to make sure that we are running the idle func and draining all worker
2118                          * gray queues. The operation of starting workers implies this, so we start them after
2119                          * in order to avoid doing this operation twice. The workers will drain the main gray
2120                          * stack that contained roots and pinned objects and also scan the mod union card
2121                          * table.
2122                          */
2123                         sgen_workers_start_all_workers (GENERATION_OLD, object_ops_nopar, object_ops_par, NULL);
2124                         sgen_workers_join (GENERATION_OLD);
2125                 }
2126         }
2127
2128         sgen_pin_stats_report ();
2129
2130         if (mode == COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT) {
2131                 sgen_finish_pinning ();
2132
2133                 sgen_pin_stats_reset ();
2134
2135                 if (do_concurrent_checks)
2136                         sgen_debug_check_nursery_is_clean ();
2137         }
2138 }
2139
2140 static void
2141 major_start_collection (SgenGrayQueue *gc_thread_gray_queue, const char *reason, gboolean concurrent, size_t *old_next_pin_slot)
2142 {
2143         SgenObjectOperations *object_ops_nopar, *object_ops_par = NULL;
2144
2145         binary_protocol_collection_begin (InterlockedRead (&gc_stats.major_gc_count), GENERATION_OLD);
2146
2147         current_collection_generation = GENERATION_OLD;
2148
2149         sgen_workers_assert_gray_queue_is_empty (GENERATION_OLD);
2150
2151         if (!concurrent)
2152                 sgen_cement_reset ();
2153
2154         if (concurrent) {
2155                 g_assert (major_collector.is_concurrent);
2156                 concurrent_collection_in_progress = TRUE;
2157
2158                 object_ops_nopar = &major_collector.major_ops_concurrent_start;
2159                 if (major_collector.is_parallel)
2160                         object_ops_par = &major_collector.major_ops_conc_par_start;
2161
2162         } else {
2163                 object_ops_nopar = &major_collector.major_ops_serial;
2164         }
2165
2166         reset_pinned_from_failed_allocation ();
2167
2168         sgen_memgov_major_collection_start (concurrent, reason);
2169
2170         //count_ref_nonref_objs ();
2171         //consistency_check ();
2172
2173         check_scan_starts ();
2174
2175         degraded_mode = 0;
2176         SGEN_LOG (1, "Start major collection %" G_GINT32_FORMAT, InterlockedRead (&gc_stats.major_gc_count));
2177         InterlockedIncrement (&gc_stats.major_gc_count);
2178
2179         if (major_collector.start_major_collection)
2180                 major_collector.start_major_collection ();
2181
2182         major_copy_or_mark_from_roots (gc_thread_gray_queue, old_next_pin_slot, concurrent ? COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT : COPY_OR_MARK_FROM_ROOTS_SERIAL, object_ops_nopar, object_ops_par);
2183 }
2184
2185 static void
2186 major_finish_collection (SgenGrayQueue *gc_thread_gray_queue, const char *reason, gboolean is_overflow, size_t old_next_pin_slot, gboolean forced)
2187 {
2188         ScannedObjectCounts counts;
2189         SgenObjectOperations *object_ops_nopar;
2190         mword fragment_total;
2191         TV_DECLARE (atv);
2192         TV_DECLARE (btv);
2193         guint64 major_scan_start = time_major_scan_mod_union_blocks;
2194         guint64 los_scan_start = time_major_scan_mod_union_los;
2195         guint64 finish_gray_start = time_major_finish_gray_stack;
2196
2197         if (concurrent_collection_in_progress) {
2198                 SgenObjectOperations *object_ops_par = NULL;
2199
2200                 object_ops_nopar = &major_collector.major_ops_concurrent_finish;
2201                 if (major_collector.is_parallel)
2202                         object_ops_par = &major_collector.major_ops_conc_par_finish;
2203
2204                 major_copy_or_mark_from_roots (gc_thread_gray_queue, NULL, COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT, object_ops_nopar, object_ops_par);
2205
2206 #ifdef SGEN_DEBUG_INTERNAL_ALLOC
2207                 main_gc_thread = NULL;
2208 #endif
2209         } else {
2210                 object_ops_nopar = &major_collector.major_ops_serial;
2211         }
2212
2213         sgen_workers_assert_gray_queue_is_empty (GENERATION_OLD);
2214
2215         TV_GETTIME (btv);
2216         finish_gray_stack (GENERATION_OLD, CONTEXT_FROM_OBJECT_OPERATIONS (object_ops_nopar, gc_thread_gray_queue));
2217         TV_GETTIME (atv);
2218         time_major_finish_gray_stack += TV_ELAPSED (btv, atv);
2219
2220         SGEN_ASSERT (0, sgen_workers_all_done (), "Can't have workers working after joining");
2221
2222         if (objects_pinned) {
2223                 g_assert (!concurrent_collection_in_progress);
2224
2225                 /*
2226                  * This is slow, but we just OOM'd.
2227                  *
2228                  * See comment at `sgen_pin_queue_clear_discarded_entries` for how the pin
2229                  * queue is laid out at this point.
2230                  */
2231                 sgen_pin_queue_clear_discarded_entries (nursery_section, old_next_pin_slot);
2232                 /*
2233                  * We need to reestablish all pinned nursery objects in the pin queue
2234                  * because they're needed for fragment creation.  Unpinning happens by
2235                  * walking the whole queue, so it's not necessary to reestablish where major
2236                  * heap block pins are - all we care is that they're still in there
2237                  * somewhere.
2238                  */
2239                 sgen_optimize_pin_queue ();
2240                 sgen_find_section_pin_queue_start_end (nursery_section);
2241                 objects_pinned = 0;
2242         }
2243
2244         reset_heap_boundaries ();
2245         sgen_update_heap_boundaries ((mword)sgen_get_nursery_start (), (mword)sgen_get_nursery_end ());
2246
2247         /* walk the pin_queue, build up the fragment list of free memory, unmark
2248          * pinned objects as we go, memzero() the empty fragments so they are ready for the
2249          * next allocations.
2250          */
2251         fragment_total = sgen_build_nursery_fragments (nursery_section, NULL);
2252         if (!fragment_total)
2253                 degraded_mode = 1;
2254         SGEN_LOG (4, "Free space in nursery after major %ld", (long)fragment_total);
2255
2256         if (do_concurrent_checks && concurrent_collection_in_progress)
2257                 sgen_debug_check_nursery_is_clean ();
2258
2259         /* prepare the pin queue for the next collection */
2260         sgen_finish_pinning ();
2261
2262         /* Clear TLABs for all threads */
2263         sgen_clear_tlabs ();
2264
2265         sgen_pin_stats_reset ();
2266
2267         sgen_cement_clear_below_threshold ();
2268
2269         if (check_mark_bits_after_major_collection)
2270                 sgen_check_heap_marked (concurrent_collection_in_progress);
2271
2272         TV_GETTIME (btv);
2273         time_major_fragment_creation += TV_ELAPSED (atv, btv);
2274
2275         binary_protocol_sweep_begin (GENERATION_OLD, !major_collector.sweeps_lazily);
2276         sgen_memgov_major_pre_sweep ();
2277
2278         TV_GETTIME (atv);
2279         time_major_free_bigobjs += TV_ELAPSED (btv, atv);
2280
2281         sgen_los_sweep ();
2282
2283         TV_GETTIME (btv);
2284         time_major_los_sweep += TV_ELAPSED (atv, btv);
2285
2286         major_collector.sweep ();
2287
2288         binary_protocol_sweep_end (GENERATION_OLD, !major_collector.sweeps_lazily);
2289
2290         TV_GETTIME (atv);
2291         time_major_sweep += TV_ELAPSED (btv, atv);
2292
2293         sgen_debug_dump_heap ("major", InterlockedRead (&gc_stats.major_gc_count) - 1, reason);
2294
2295         if (sgen_have_pending_finalizers ()) {
2296                 SGEN_LOG (4, "Finalizer-thread wakeup");
2297                 sgen_client_finalize_notify ();
2298         }
2299
2300         sgen_memgov_major_collection_end (forced, concurrent_collection_in_progress, reason, is_overflow);
2301         current_collection_generation = -1;
2302
2303         memset (&counts, 0, sizeof (ScannedObjectCounts));
2304         major_collector.finish_major_collection (&counts);
2305
2306         sgen_workers_assert_gray_queue_is_empty (GENERATION_OLD);
2307
2308         SGEN_ASSERT (0, sgen_workers_all_done (), "Can't have workers working after major collection has finished");
2309         if (concurrent_collection_in_progress)
2310                 concurrent_collection_in_progress = FALSE;
2311
2312         check_scan_starts ();
2313
2314         binary_protocol_flush_buffers (FALSE);
2315
2316         //consistency_check ();
2317         if (major_collector.is_parallel)
2318                 binary_protocol_collection_end_stats (0, 0, time_major_finish_gray_stack - finish_gray_start);
2319         else
2320                 binary_protocol_collection_end_stats (
2321                         time_major_scan_mod_union_blocks - major_scan_start,
2322                         time_major_scan_mod_union_los - los_scan_start,
2323                         time_major_finish_gray_stack - finish_gray_start);
2324
2325         binary_protocol_collection_end (InterlockedRead (&gc_stats.major_gc_count) - 1, GENERATION_OLD, counts.num_scanned_objects, counts.num_unique_scanned_objects);
2326 }
2327
2328 static gboolean
2329 major_do_collection (const char *reason, gboolean is_overflow, gboolean forced)
2330 {
2331         TV_DECLARE (time_start);
2332         TV_DECLARE (time_end);
2333         size_t old_next_pin_slot;
2334         SgenGrayQueue gc_thread_gray_queue;
2335
2336         if (disable_major_collections)
2337                 return FALSE;
2338
2339         if (major_collector.get_and_reset_num_major_objects_marked) {
2340                 long long num_marked = major_collector.get_and_reset_num_major_objects_marked ();
2341                 g_assert (!num_marked);
2342         }
2343
2344         /* world must be stopped already */
2345         TV_GETTIME (time_start);
2346
2347         init_gray_queue (&gc_thread_gray_queue);
2348         major_start_collection (&gc_thread_gray_queue, reason, FALSE, &old_next_pin_slot);
2349         major_finish_collection (&gc_thread_gray_queue, reason, is_overflow, old_next_pin_slot, forced);
2350         sgen_gray_object_queue_dispose (&gc_thread_gray_queue);
2351
2352         TV_GETTIME (time_end);
2353         UnlockedAdd64 (&gc_stats.major_gc_time, TV_ELAPSED (time_start, time_end));
2354
2355         /* FIXME: also report this to the user, preferably in gc-end. */
2356         if (major_collector.get_and_reset_num_major_objects_marked)
2357                 major_collector.get_and_reset_num_major_objects_marked ();
2358
2359         return bytes_pinned_from_failed_allocation > 0;
2360 }
2361
2362 static void
2363 major_start_concurrent_collection (const char *reason)
2364 {
2365         TV_DECLARE (time_start);
2366         TV_DECLARE (time_end);
2367         long long num_objects_marked;
2368         SgenGrayQueue gc_thread_gray_queue;
2369
2370         if (disable_major_collections)
2371                 return;
2372
2373         TV_GETTIME (time_start);
2374         SGEN_TV_GETTIME (time_major_conc_collection_start);
2375
2376         num_objects_marked = major_collector.get_and_reset_num_major_objects_marked ();
2377         g_assert (num_objects_marked == 0);
2378
2379         binary_protocol_concurrent_start ();
2380
2381         init_gray_queue (&gc_thread_gray_queue);
2382         // FIXME: store reason and pass it when finishing
2383         major_start_collection (&gc_thread_gray_queue, reason, TRUE, NULL);
2384         sgen_gray_object_queue_dispose (&gc_thread_gray_queue);
2385
2386         num_objects_marked = major_collector.get_and_reset_num_major_objects_marked ();
2387
2388         TV_GETTIME (time_end);
2389         UnlockedAdd64 (&gc_stats.major_gc_time, TV_ELAPSED (time_start, time_end));
2390
2391         current_collection_generation = -1;
2392 }
2393
2394 /*
2395  * Returns whether the major collection has finished.
2396  */
2397 static gboolean
2398 major_should_finish_concurrent_collection (void)
2399 {
2400         return sgen_workers_all_done ();
2401 }
2402
2403 static void
2404 major_update_concurrent_collection (void)
2405 {
2406         TV_DECLARE (total_start);
2407         TV_DECLARE (total_end);
2408
2409         TV_GETTIME (total_start);
2410
2411         binary_protocol_concurrent_update ();
2412
2413         major_collector.update_cardtable_mod_union ();
2414         sgen_los_update_cardtable_mod_union ();
2415
2416         TV_GETTIME (total_end);
2417         UnlockedAdd64 (&gc_stats.major_gc_time, TV_ELAPSED (total_start, total_end));
2418 }
2419
2420 static void
2421 major_finish_concurrent_collection (gboolean forced)
2422 {
2423         SgenGrayQueue gc_thread_gray_queue;
2424         TV_DECLARE (total_start);
2425         TV_DECLARE (total_end);
2426
2427         TV_GETTIME (total_start);
2428
2429         binary_protocol_concurrent_finish ();
2430
2431         /*
2432          * We need to stop all workers since we're updating the cardtable below.
2433          * The workers will be resumed with a finishing pause context to avoid
2434          * additional cardtable and object scanning.
2435          */
2436         sgen_workers_stop_all_workers (GENERATION_OLD);
2437
2438         SGEN_TV_GETTIME (time_major_conc_collection_end);
2439         UnlockedAdd64 (&gc_stats.major_gc_time_concurrent, SGEN_TV_ELAPSED (time_major_conc_collection_start, time_major_conc_collection_end));
2440
2441         major_collector.update_cardtable_mod_union ();
2442         sgen_los_update_cardtable_mod_union ();
2443
2444         if (mod_union_consistency_check)
2445                 sgen_check_mod_union_consistency ();
2446
2447         current_collection_generation = GENERATION_OLD;
2448         sgen_cement_reset ();
2449         init_gray_queue (&gc_thread_gray_queue);
2450         major_finish_collection (&gc_thread_gray_queue, "finishing", FALSE, -1, forced);
2451         sgen_gray_object_queue_dispose (&gc_thread_gray_queue);
2452
2453         TV_GETTIME (total_end);
2454         UnlockedAdd64 (&gc_stats.major_gc_time, TV_ELAPSED (total_start, total_end));
2455
2456         current_collection_generation = -1;
2457 }
2458
2459 /*
2460  * Ensure an allocation request for @size will succeed by freeing enough memory.
2461  *
2462  * LOCKING: The GC lock MUST be held.
2463  */
2464 void
2465 sgen_ensure_free_space (size_t size, int generation)
2466 {
2467         int generation_to_collect = -1;
2468         const char *reason = NULL;
2469
2470         if (generation == GENERATION_OLD) {
2471                 if (sgen_need_major_collection (size)) {
2472                         reason = "LOS overflow";
2473                         generation_to_collect = GENERATION_OLD;
2474                 }
2475         } else {
2476                 if (degraded_mode) {
2477                         if (sgen_need_major_collection (size)) {
2478                                 reason = "Degraded mode overflow";
2479                                 generation_to_collect = GENERATION_OLD;
2480                         }
2481                 } else if (sgen_need_major_collection (size)) {
2482                         reason = concurrent_collection_in_progress ? "Forced finish concurrent collection" : "Minor allowance";
2483                         generation_to_collect = GENERATION_OLD;
2484                 } else {
2485                         generation_to_collect = GENERATION_NURSERY;
2486                         reason = "Nursery full";
2487                 }
2488         }
2489
2490         if (generation_to_collect == -1) {
2491                 if (concurrent_collection_in_progress && sgen_workers_all_done ()) {
2492                         generation_to_collect = GENERATION_OLD;
2493                         reason = "Finish concurrent collection";
2494                 }
2495         }
2496
2497         if (generation_to_collect == -1)
2498                 return;
2499         sgen_perform_collection (size, generation_to_collect, reason, FALSE, TRUE);
2500 }
2501
2502 /*
2503  * LOCKING: Assumes the GC lock is held.
2504  */
2505 void
2506 sgen_perform_collection_inner (size_t requested_size, int generation_to_collect, const char *reason, gboolean wait_to_finish, gboolean stw)
2507 {
2508         TV_DECLARE (gc_total_start);
2509         TV_DECLARE (gc_total_end);
2510         int overflow_generation_to_collect = -1;
2511         int oldest_generation_collected = generation_to_collect;
2512         const char *overflow_reason = NULL;
2513         gboolean finish_concurrent = concurrent_collection_in_progress && (major_should_finish_concurrent_collection () || generation_to_collect == GENERATION_OLD);
2514
2515         binary_protocol_collection_requested (generation_to_collect, requested_size, wait_to_finish ? 1 : 0);
2516
2517         SGEN_ASSERT (0, generation_to_collect == GENERATION_NURSERY || generation_to_collect == GENERATION_OLD, "What generation is this?");
2518
2519         if (stw)
2520                 sgen_stop_world (generation_to_collect);
2521         else
2522                 SGEN_ASSERT (0, sgen_is_world_stopped (), "We can only collect if the world is stopped");
2523
2524
2525         TV_GETTIME (gc_total_start);
2526
2527         // FIXME: extract overflow reason
2528         // FIXME: minor overflow for concurrent case
2529         if (generation_to_collect == GENERATION_NURSERY && !finish_concurrent) {
2530                 if (concurrent_collection_in_progress)
2531                         major_update_concurrent_collection ();
2532
2533                 if (collect_nursery (reason, FALSE, NULL) && !concurrent_collection_in_progress) {
2534                         overflow_generation_to_collect = GENERATION_OLD;
2535                         overflow_reason = "Minor overflow";
2536                 }
2537         } else if (finish_concurrent) {
2538                 major_finish_concurrent_collection (wait_to_finish);
2539                 oldest_generation_collected = GENERATION_OLD;
2540         } else {
2541                 SGEN_ASSERT (0, generation_to_collect == GENERATION_OLD, "We should have handled nursery collections above");
2542                 if (major_collector.is_concurrent && !wait_to_finish) {
2543                         collect_nursery ("Concurrent start", FALSE, NULL);
2544                         major_start_concurrent_collection (reason);
2545                         oldest_generation_collected = GENERATION_NURSERY;
2546                 } else if (major_do_collection (reason, FALSE, wait_to_finish)) {
2547                         overflow_generation_to_collect = GENERATION_NURSERY;
2548                         overflow_reason = "Excessive pinning";
2549                 }
2550         }
2551
2552         if (overflow_generation_to_collect != -1) {
2553                 SGEN_ASSERT (0, !concurrent_collection_in_progress, "We don't yet support overflow collections with the concurrent collector");
2554
2555                 /*
2556                  * We need to do an overflow collection, either because we ran out of memory
2557                  * or the nursery is fully pinned.
2558                  */
2559
2560                 if (overflow_generation_to_collect == GENERATION_NURSERY)
2561                         collect_nursery (overflow_reason, TRUE, NULL);
2562                 else
2563                         major_do_collection (overflow_reason, TRUE, wait_to_finish);
2564
2565                 oldest_generation_collected = MAX (oldest_generation_collected, overflow_generation_to_collect);
2566         }
2567
2568         SGEN_LOG (2, "Heap size: %lu, LOS size: %lu", (unsigned long)sgen_gc_get_total_heap_allocation (), (unsigned long)los_memory_usage);
2569
2570         /* this also sets the proper pointers for the next allocation */
2571         if (generation_to_collect == GENERATION_NURSERY && !sgen_can_alloc_size (requested_size)) {
2572                 /* TypeBuilder and MonoMethod are killing mcs with fragmentation */
2573                 SGEN_LOG (1, "nursery collection didn't find enough room for %zd alloc (%zd pinned)", requested_size, sgen_get_pinned_count ());
2574                 sgen_dump_pin_queue ();
2575                 degraded_mode = 1;
2576         }
2577
2578         TV_GETTIME (gc_total_end);
2579         time_max = MAX (time_max, TV_ELAPSED (gc_total_start, gc_total_end));
2580
2581         if (stw)
2582                 sgen_restart_world (oldest_generation_collected);
2583 }
2584
2585 #ifdef HOST_WASM
2586
2587 typedef struct {
2588         size_t requested_size;
2589         int generation_to_collect;
2590         const char *reason;
2591 } SgenGcRequest;
2592
2593 static SgenGcRequest gc_request;
2594 static gboolean pending_request;
2595
2596 extern void request_gc_cycle (void);
2597
2598 #include <emscripten.h>
2599
2600 EMSCRIPTEN_KEEPALIVE void
2601 mono_gc_pump_callback (void)
2602 {
2603         if (!pending_request)
2604                 return;
2605         pending_request = FALSE;
2606         sgen_perform_collection_inner (gc_request.requested_size, gc_request.generation_to_collect, gc_request.reason, TRUE, TRUE);
2607 }
2608 #endif
2609
2610 void
2611 sgen_perform_collection (size_t requested_size, int generation_to_collect, const char *reason, gboolean wait_to_finish, gboolean stw)
2612 {
2613 #ifdef HOST_WASM
2614         g_assert (stw); //can't handle non-stw mode (IE, domain unload)
2615         //we ignore wait_to_finish
2616         if (!pending_request || gc_request.generation_to_collect <= generation_to_collect) { //no active request or request was for a smaller part of the heap
2617                 gc_request.requested_size = requested_size;
2618                 gc_request.generation_to_collect = generation_to_collect;
2619                 gc_request.reason = reason;
2620                 if (!pending_request) {
2621                         request_gc_cycle ();
2622                         pending_request = TRUE;
2623                 }
2624         }
2625
2626         degraded_mode = 1; //enable degraded mode so allocation can continue
2627 #else
2628         sgen_perform_collection_inner (requested_size, generation_to_collect, reason, wait_to_finish, stw);
2629 #endif
2630 }
2631 /*
2632  * ######################################################################
2633  * ########  Memory allocation from the OS
2634  * ######################################################################
2635  * This section of code deals with getting memory from the OS and
2636  * allocating memory for GC-internal data structures.
2637  * Internal memory can be handled with a freelist for small objects.
2638  */
2639
2640 /*
2641  * Debug reporting.
2642  */
2643 G_GNUC_UNUSED static void
2644 report_internal_mem_usage (void)
2645 {
2646         printf ("Internal memory usage:\n");
2647         sgen_report_internal_mem_usage ();
2648         printf ("Pinned memory usage:\n");
2649         major_collector.report_pinned_memory_usage ();
2650 }
2651
2652 /*
2653  * ######################################################################
2654  * ########  Finalization support
2655  * ######################################################################
2656  */
2657
2658 /*
2659  * If the object has been forwarded it means it's still referenced from a root.
2660  * If it is pinned it's still alive as well.
2661  * A LOS object is only alive if we have pinned it.
2662  * Return TRUE if @obj is ready to be finalized.
2663  */
2664 static inline gboolean
2665 sgen_is_object_alive (GCObject *object)
2666 {
2667         if (ptr_in_nursery (object))
2668                 return sgen_nursery_is_object_alive (object);
2669
2670         return sgen_major_is_object_alive (object);
2671 }
2672
2673 /*
2674  * This function returns true if @object is either alive and belongs to the
2675  * current collection - major collections are full heap, so old gen objects
2676  * are never alive during a minor collection.
2677  */
2678 static inline int
2679 sgen_is_object_alive_and_on_current_collection (GCObject *object)
2680 {
2681         if (ptr_in_nursery (object))
2682                 return sgen_nursery_is_object_alive (object);
2683
2684         if (current_collection_generation == GENERATION_NURSERY)
2685                 return FALSE;
2686
2687         return sgen_major_is_object_alive (object);
2688 }
2689
2690
2691 gboolean
2692 sgen_gc_is_object_ready_for_finalization (GCObject *object)
2693 {
2694         return !sgen_is_object_alive (object);
2695 }
2696
2697 void
2698 sgen_queue_finalization_entry (GCObject *obj)
2699 {
2700         gboolean critical = sgen_client_object_has_critical_finalizer (obj);
2701
2702         sgen_pointer_queue_add (critical ? &critical_fin_queue : &fin_ready_queue, obj);
2703
2704         sgen_client_object_queued_for_finalization (obj);
2705 }
2706
2707 gboolean
2708 sgen_object_is_live (GCObject *obj)
2709 {
2710         return sgen_is_object_alive_and_on_current_collection (obj);
2711 }
2712
2713 /*
2714  * `System.GC.WaitForPendingFinalizers` first checks `sgen_have_pending_finalizers()` to
2715  * determine whether it can exit quickly.  The latter must therefore only return FALSE if
2716  * all finalizers have really finished running.
2717  *
2718  * `sgen_gc_invoke_finalizers()` first dequeues a finalizable object, and then finalizes it.
2719  * This means that just checking whether the queues are empty leaves the possibility that an
2720  * object might have been dequeued but not yet finalized.  That's why we need the additional
2721  * flag `pending_unqueued_finalizer`.
2722  */
2723
2724 static volatile gboolean pending_unqueued_finalizer = FALSE;
2725 volatile gboolean sgen_suspend_finalizers = FALSE;
2726
2727 void
2728 sgen_set_suspend_finalizers (void)
2729 {
2730         sgen_suspend_finalizers = TRUE;
2731 }
2732
2733 int
2734 sgen_gc_invoke_finalizers (void)
2735 {
2736         int count = 0;
2737
2738         g_assert (!pending_unqueued_finalizer);
2739
2740         /* FIXME: batch to reduce lock contention */
2741         while (sgen_have_pending_finalizers ()) {
2742                 GCObject *obj;
2743
2744                 LOCK_GC;
2745
2746                 /*
2747                  * We need to set `pending_unqueued_finalizer` before dequeing the
2748                  * finalizable object.
2749                  */
2750                 if (!sgen_pointer_queue_is_empty (&fin_ready_queue)) {
2751                         pending_unqueued_finalizer = TRUE;
2752                         mono_memory_write_barrier ();
2753                         obj = (GCObject *)sgen_pointer_queue_pop (&fin_ready_queue);
2754                 } else if (!sgen_pointer_queue_is_empty (&critical_fin_queue)) {
2755                         pending_unqueued_finalizer = TRUE;
2756                         mono_memory_write_barrier ();
2757                         obj = (GCObject *)sgen_pointer_queue_pop (&critical_fin_queue);
2758                 } else {
2759                         obj = NULL;
2760                 }
2761
2762                 if (obj)
2763                         SGEN_LOG (7, "Finalizing object %p (%s)", obj, sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (obj)));
2764
2765                 UNLOCK_GC;
2766
2767                 if (!obj)
2768                         break;
2769
2770                 count++;
2771                 /* the object is on the stack so it is pinned */
2772                 /*g_print ("Calling finalizer for object: %p (%s)\n", obj, sgen_client_object_safe_name (obj));*/
2773                 sgen_client_run_finalize (obj);
2774         }
2775
2776         if (pending_unqueued_finalizer) {
2777                 mono_memory_write_barrier ();
2778                 pending_unqueued_finalizer = FALSE;
2779         }
2780
2781         return count;
2782 }
2783
2784 gboolean
2785 sgen_have_pending_finalizers (void)
2786 {
2787         if (sgen_suspend_finalizers)
2788                 return FALSE;
2789         return pending_unqueued_finalizer || !sgen_pointer_queue_is_empty (&fin_ready_queue) || !sgen_pointer_queue_is_empty (&critical_fin_queue);
2790 }
2791
2792 /*
2793  * ######################################################################
2794  * ########  registered roots support
2795  * ######################################################################
2796  */
2797
2798 /*
2799  * We do not coalesce roots.
2800  */
2801 int
2802 sgen_register_root (char *start, size_t size, SgenDescriptor descr, int root_type, int source, const char *msg)
2803 {
2804         RootRecord new_root;
2805         int i;
2806         LOCK_GC;
2807         for (i = 0; i < ROOT_TYPE_NUM; ++i) {
2808                 RootRecord *root = (RootRecord *)sgen_hash_table_lookup (&roots_hash [i], start);
2809                 /* we allow changing the size and the descriptor (for thread statics etc) */
2810                 if (root) {
2811                         size_t old_size = root->end_root - start;
2812                         root->end_root = start + size;
2813                         SGEN_ASSERT (0, !!root->root_desc == !!descr, "Can't change whether a root is precise or conservative.");
2814                         SGEN_ASSERT (0, root->source == source, "Can't change a root's source identifier.");
2815                         SGEN_ASSERT (0, !!root->msg == !!msg, "Can't change a root's message.");
2816                         root->root_desc = descr;
2817                         roots_size += size;
2818                         roots_size -= old_size;
2819                         UNLOCK_GC;
2820                         return TRUE;
2821                 }
2822         }
2823
2824         new_root.end_root = start + size;
2825         new_root.root_desc = descr;
2826         new_root.source = source;
2827         new_root.msg = msg;
2828
2829         sgen_hash_table_replace (&roots_hash [root_type], start, &new_root, NULL);
2830         roots_size += size;
2831
2832         SGEN_LOG (3, "Added root for range: %p-%p, descr: %llx  (%d/%d bytes)", start, new_root.end_root, (long long)descr, (int)size, (int)roots_size);
2833
2834         UNLOCK_GC;
2835         return TRUE;
2836 }
2837
2838 void
2839 sgen_deregister_root (char* addr)
2840 {
2841         int root_type;
2842         RootRecord root;
2843
2844         LOCK_GC;
2845         for (root_type = 0; root_type < ROOT_TYPE_NUM; ++root_type) {
2846                 if (sgen_hash_table_remove (&roots_hash [root_type], addr, &root))
2847                         roots_size -= (root.end_root - addr);
2848         }
2849         UNLOCK_GC;
2850 }
2851
2852 void
2853 sgen_wbroots_iterate_live_block_ranges (sgen_cardtable_block_callback cb)
2854 {
2855         void **start_root;
2856         RootRecord *root;
2857         SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_WBARRIER], void **, start_root, RootRecord *, root) {
2858                 cb ((mword)start_root, (mword)root->end_root - (mword)start_root);
2859         } SGEN_HASH_TABLE_FOREACH_END;
2860 }
2861
2862 /* Root equivalent of sgen_client_cardtable_scan_object */
2863 static void
2864 sgen_wbroot_scan_card_table (void** start_root, mword size,  ScanCopyContext ctx)
2865 {
2866         ScanPtrFieldFunc scan_field_func = ctx.ops->scan_ptr_field;
2867         guint8 *card_data = sgen_card_table_get_card_scan_address ((mword)start_root);
2868         guint8 *card_base = card_data;
2869         mword card_count = sgen_card_table_number_of_cards_in_range ((mword)start_root, size);
2870         guint8 *card_data_end = card_data + card_count;
2871         mword extra_idx = 0;
2872         char *obj_start = sgen_card_table_align_pointer (start_root);
2873         char *obj_end = (char*)start_root + size;
2874 #ifdef SGEN_HAVE_OVERLAPPING_CARDS
2875         guint8 *overflow_scan_end = NULL;
2876 #endif
2877
2878 #ifdef SGEN_HAVE_OVERLAPPING_CARDS
2879         /*Check for overflow and if so, setup to scan in two steps*/
2880         if (card_data_end >= SGEN_SHADOW_CARDTABLE_END) {
2881                 overflow_scan_end = sgen_shadow_cardtable + (card_data_end - SGEN_SHADOW_CARDTABLE_END);
2882                 card_data_end = SGEN_SHADOW_CARDTABLE_END;
2883         }
2884
2885 LOOP_HEAD:
2886 #endif
2887
2888         card_data = sgen_find_next_card (card_data, card_data_end);
2889
2890         for (; card_data < card_data_end; card_data = sgen_find_next_card (card_data + 1, card_data_end)) {
2891                 size_t idx = (card_data - card_base) + extra_idx;
2892                 char *start = (char*)(obj_start + idx * CARD_SIZE_IN_BYTES);
2893                 char *card_end = start + CARD_SIZE_IN_BYTES;
2894                 char *elem = start, *first_elem = start;
2895
2896                 /*
2897                  * Don't clean first and last card on 32bit systems since they
2898                  * may also be part from other roots.
2899                  */
2900                 if (card_data != card_base && card_data != (card_data_end - 1))
2901                         sgen_card_table_prepare_card_for_scanning (card_data);
2902
2903                 card_end = MIN (card_end, obj_end);
2904
2905                 if (elem < (char*)start_root)
2906                         first_elem = elem = (char*)start_root;
2907
2908                 for (; elem < card_end; elem += SIZEOF_VOID_P) {
2909                         if (*(GCObject**)elem)
2910                                 scan_field_func (NULL, (GCObject**)elem, ctx.queue);
2911                 }
2912
2913                 binary_protocol_card_scan (first_elem, elem - first_elem);
2914         }
2915
2916 #ifdef SGEN_HAVE_OVERLAPPING_CARDS
2917         if (overflow_scan_end) {
2918                 extra_idx = card_data - card_base;
2919                 card_base = card_data = sgen_shadow_cardtable;
2920                 card_data_end = overflow_scan_end;
2921                 overflow_scan_end = NULL;
2922                 goto LOOP_HEAD;
2923         }
2924 #endif
2925 }
2926
2927 void
2928 sgen_wbroots_scan_card_table (ScanCopyContext ctx)
2929 {
2930         void **start_root;
2931         RootRecord *root;
2932
2933         SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_WBARRIER], void **, start_root, RootRecord *, root) {
2934                 SGEN_ASSERT (0, (root->root_desc & ROOT_DESC_TYPE_MASK) == ROOT_DESC_VECTOR, "Unsupported root type");
2935
2936                 sgen_wbroot_scan_card_table (start_root, (mword)root->end_root - (mword)start_root, ctx);
2937         } SGEN_HASH_TABLE_FOREACH_END;
2938 }
2939
2940 /*
2941  * ######################################################################
2942  * ########  Thread handling (stop/start code)
2943  * ######################################################################
2944  */
2945
2946 int
2947 sgen_get_current_collection_generation (void)
2948 {
2949         return current_collection_generation;
2950 }
2951
2952 void*
2953 sgen_thread_attach (SgenThreadInfo* info)
2954 {
2955         info->tlab_start = info->tlab_next = info->tlab_temp_end = info->tlab_real_end = NULL;
2956
2957         sgen_client_thread_attach (info);
2958
2959         return info;
2960 }
2961
2962 void
2963 sgen_thread_detach_with_lock (SgenThreadInfo *p)
2964 {
2965         sgen_client_thread_detach_with_lock (p);
2966 }
2967
2968 /*
2969  * ######################################################################
2970  * ########  Write barriers
2971  * ######################################################################
2972  */
2973
2974 /*
2975  * Note: the write barriers first do the needed GC work and then do the actual store:
2976  * this way the value is visible to the conservative GC scan after the write barrier
2977  * itself. If a GC interrupts the barrier in the middle, value will be kept alive by
2978  * the conservative scan, otherwise by the remembered set scan.
2979  */
2980
2981 /**
2982  * mono_gc_wbarrier_arrayref_copy:
2983  */
2984 void
2985 mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
2986 {
2987         HEAVY_STAT (++stat_wbarrier_arrayref_copy);
2988         /*This check can be done without taking a lock since dest_ptr array is pinned*/
2989         if (ptr_in_nursery (dest_ptr) || count <= 0) {
2990                 mono_gc_memmove_aligned (dest_ptr, src_ptr, count * sizeof (gpointer));
2991                 return;
2992         }
2993
2994 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
2995         if (binary_protocol_is_heavy_enabled ()) {
2996                 int i;
2997                 for (i = 0; i < count; ++i) {
2998                         gpointer dest = (gpointer*)dest_ptr + i;
2999                         gpointer obj = *((gpointer*)src_ptr + i);
3000                         if (obj)
3001                                 binary_protocol_wbarrier (dest, obj, (gpointer)LOAD_VTABLE (obj));
3002                 }
3003         }
3004 #endif
3005
3006         remset.wbarrier_arrayref_copy (dest_ptr, src_ptr, count);
3007 }
3008
3009 /**
3010  * mono_gc_wbarrier_generic_nostore:
3011  */
3012 void
3013 mono_gc_wbarrier_generic_nostore (gpointer ptr)
3014 {
3015         gpointer obj;
3016
3017         HEAVY_STAT (++stat_wbarrier_generic_store);
3018
3019         sgen_client_wbarrier_generic_nostore_check (ptr);
3020
3021         obj = *(gpointer*)ptr;
3022         if (obj)
3023                 binary_protocol_wbarrier (ptr, obj, (gpointer)LOAD_VTABLE (obj));
3024
3025         /*
3026          * We need to record old->old pointer locations for the
3027          * concurrent collector.
3028          */
3029         if (!ptr_in_nursery (obj) && !concurrent_collection_in_progress) {
3030                 SGEN_LOG (8, "Skipping remset at %p", ptr);
3031                 return;
3032         }
3033
3034         SGEN_LOG (8, "Adding remset at %p", ptr);
3035
3036         remset.wbarrier_generic_nostore (ptr);
3037 }
3038
3039 /**
3040  * mono_gc_wbarrier_generic_store:
3041  */
3042 void
3043 mono_gc_wbarrier_generic_store (gpointer ptr, GCObject* value)
3044 {
3045         SGEN_LOG (8, "Wbarrier store at %p to %p (%s)", ptr, value, value ? sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (value)) : "null");
3046         SGEN_UPDATE_REFERENCE_ALLOW_NULL (ptr, value);
3047         if (ptr_in_nursery (value) || concurrent_collection_in_progress)
3048                 mono_gc_wbarrier_generic_nostore (ptr);
3049         sgen_dummy_use (value);
3050 }
3051
3052 /**
3053  * mono_gc_wbarrier_generic_store_atomic:
3054  * Same as \c mono_gc_wbarrier_generic_store but performs the store
3055  * as an atomic operation with release semantics.
3056  */
3057 void
3058 mono_gc_wbarrier_generic_store_atomic (gpointer ptr, GCObject *value)
3059 {
3060         HEAVY_STAT (++stat_wbarrier_generic_store_atomic);
3061
3062         SGEN_LOG (8, "Wbarrier atomic store at %p to %p (%s)", ptr, value, value ? sgen_client_vtable_get_name (SGEN_LOAD_VTABLE (value)) : "null");
3063
3064         InterlockedWritePointer ((volatile gpointer *)ptr, value);
3065
3066         if (ptr_in_nursery (value) || concurrent_collection_in_progress)
3067                 mono_gc_wbarrier_generic_nostore (ptr);
3068
3069         sgen_dummy_use (value);
3070 }
3071
3072 void
3073 sgen_wbarrier_range_copy (gpointer _dest, gpointer _src, int size)
3074 {
3075         remset.wbarrier_range_copy (_dest,_src, size);
3076 }
3077
3078 /*
3079  * ######################################################################
3080  * ########  Other mono public interface functions.
3081  * ######################################################################
3082  */
3083
3084 void
3085 sgen_gc_collect (int generation)
3086 {
3087         LOCK_GC;
3088         if (generation > 1)
3089                 generation = 1;
3090         sgen_perform_collection (0, generation, "user request", TRUE, TRUE);
3091         UNLOCK_GC;
3092 }
3093
3094 int
3095 sgen_gc_collection_count (int generation)
3096 {
3097         return InterlockedRead (generation == GENERATION_NURSERY ? &gc_stats.minor_gc_count : &gc_stats.major_gc_count);
3098 }
3099
3100 size_t
3101 sgen_gc_get_used_size (void)
3102 {
3103         gint64 tot = 0;
3104         LOCK_GC;
3105         tot = los_memory_usage;
3106         tot += nursery_section->end_data - nursery_section->data;
3107         tot += major_collector.get_used_size ();
3108         /* FIXME: account for pinned objects */
3109         UNLOCK_GC;
3110         return tot;
3111 }
3112
3113 void
3114 sgen_env_var_error (const char *env_var, const char *fallback, const char *description_format, ...)
3115 {
3116         va_list ap;
3117
3118         va_start (ap, description_format);
3119
3120         fprintf (stderr, "Warning: In environment variable `%s': ", env_var);
3121         vfprintf (stderr, description_format, ap);
3122         if (fallback)
3123                 fprintf (stderr, " - %s", fallback);
3124         fprintf (stderr, "\n");
3125
3126         va_end (ap);
3127 }
3128
3129 static gboolean
3130 parse_double_in_interval (const char *env_var, const char *opt_name, const char *opt, double min, double max, double *result)
3131 {
3132         char *endptr;
3133         double val = strtod (opt, &endptr);
3134         if (endptr == opt) {
3135                 sgen_env_var_error (env_var, "Using default value.", "`%s` must be a number.", opt_name);
3136                 return FALSE;
3137         }
3138         else if (val < min || val > max) {
3139                 sgen_env_var_error (env_var, "Using default value.", "`%s` must be between %.2f - %.2f.", opt_name, min, max);
3140                 return FALSE;
3141         }
3142         *result = val;
3143         return TRUE;
3144 }
3145
3146 static SgenMinor
3147 parse_sgen_minor (const char *opt)
3148 {
3149         if (!opt)
3150                 return SGEN_MINOR_DEFAULT;
3151
3152         if (!strcmp (opt, "simple")) {
3153                 return SGEN_MINOR_SIMPLE;
3154         } else if (!strcmp (opt, "simple-par")) {
3155                 return SGEN_MINOR_SIMPLE_PARALLEL;
3156         } else if (!strcmp (opt, "split")) {
3157                 return SGEN_MINOR_SPLIT;
3158         } else {
3159                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default instead.", "Unknown minor collector `%s'.", opt);
3160                 return SGEN_MINOR_DEFAULT;
3161         }
3162 }
3163
3164 static SgenMajor
3165 parse_sgen_major (const char *opt)
3166 {
3167         if (!opt)
3168                 return SGEN_MAJOR_DEFAULT;
3169
3170         if (!strcmp (opt, "marksweep")) {
3171                 return SGEN_MAJOR_SERIAL;
3172         } else if (!strcmp (opt, "marksweep-conc")) {
3173                 return SGEN_MAJOR_CONCURRENT;
3174         } else if (!strcmp (opt, "marksweep-conc-par")) {
3175                 return SGEN_MAJOR_CONCURRENT_PARALLEL;
3176         } else {
3177                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default instead.", "Unknown major collector `%s'.", opt);
3178                 return SGEN_MAJOR_DEFAULT;
3179         }
3180
3181 }
3182
3183 static SgenMode
3184 parse_sgen_mode (const char *opt)
3185 {
3186         if (!opt)
3187                 return SGEN_MODE_NONE;
3188
3189         if (!strcmp (opt, "balanced")) {
3190                 return SGEN_MODE_BALANCED;
3191         } else if (!strcmp (opt, "throughput")) {
3192                 return SGEN_MODE_THROUGHPUT;
3193         } else if (!strcmp (opt, "pause") || g_str_has_prefix (opt, "pause:")) {
3194                 return SGEN_MODE_PAUSE;
3195         } else {
3196                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default configurations.", "Unknown mode `%s'.", opt);
3197                 return SGEN_MODE_NONE;
3198         }
3199 }
3200
3201 static void
3202 init_sgen_minor (SgenMinor minor)
3203 {
3204         switch (minor) {
3205         case SGEN_MINOR_DEFAULT:
3206         case SGEN_MINOR_SIMPLE:
3207                 sgen_simple_nursery_init (&sgen_minor_collector, FALSE);
3208                 break;
3209         case SGEN_MINOR_SIMPLE_PARALLEL:
3210                 sgen_simple_nursery_init (&sgen_minor_collector, TRUE);
3211                 break;
3212         case SGEN_MINOR_SPLIT:
3213                 sgen_split_nursery_init (&sgen_minor_collector);
3214                 break;
3215         default:
3216                 g_assert_not_reached ();
3217         }
3218 }
3219
3220 static void
3221 init_sgen_major (SgenMajor major)
3222 {
3223         if (major == SGEN_MAJOR_DEFAULT)
3224                 major = DEFAULT_MAJOR;
3225
3226         switch (major) {
3227         case SGEN_MAJOR_SERIAL:
3228                 sgen_marksweep_init (&major_collector);
3229                 break;
3230         case SGEN_MAJOR_CONCURRENT:
3231                 sgen_marksweep_conc_init (&major_collector);
3232                 break;
3233         case SGEN_MAJOR_CONCURRENT_PARALLEL:
3234                 sgen_marksweep_conc_par_init (&major_collector);
3235                 break;
3236         default:
3237                 g_assert_not_reached ();
3238         }
3239 }
3240
3241 /*
3242  * If sgen mode is set, major/minor configuration is fixed. The other gc_params
3243  * are parsed and processed after major/minor initialization, so it can potentially
3244  * override some knobs set by the sgen mode. We can consider locking out additional
3245  * configurations when gc_modes are used.
3246  */
3247 static void
3248 init_sgen_mode (SgenMode mode)
3249 {
3250         SgenMinor minor = SGEN_MINOR_DEFAULT;
3251         SgenMajor major = SGEN_MAJOR_DEFAULT;
3252
3253         switch (mode) {
3254         case SGEN_MODE_BALANCED:
3255                 /*
3256                  * Use a dynamic parallel nursery with a major concurrent collector.
3257                  * This uses the default values for max pause time and nursery size.
3258                  */
3259                 minor = SGEN_MINOR_SIMPLE;
3260                 major = SGEN_MAJOR_CONCURRENT;
3261                 dynamic_nursery = TRUE;
3262                 break;
3263         case SGEN_MODE_THROUGHPUT:
3264                 /*
3265                  * Use concurrent major to let the mutator do more work. Use a larger
3266                  * nursery, without pause time constraints, in order to collect more
3267                  * objects in parallel and avoid repetitive collection tasks (pinning,
3268                  * root scanning etc)
3269                  */
3270                 minor = SGEN_MINOR_SIMPLE_PARALLEL;
3271                 major = SGEN_MAJOR_CONCURRENT;
3272                 dynamic_nursery = TRUE;
3273                 sgen_max_pause_time = 0;
3274                 break;
3275         case SGEN_MODE_PAUSE:
3276                 /*
3277                  * Use concurrent major and dynamic nursery with a more
3278                  * aggressive shrinking relative to pause times.
3279                  */
3280                 minor = SGEN_MINOR_SIMPLE_PARALLEL;
3281                 major = SGEN_MAJOR_CONCURRENT;
3282                 dynamic_nursery = TRUE;
3283                 sgen_max_pause_margin = SGEN_PAUSE_MODE_MAX_PAUSE_MARGIN;
3284                 break;
3285         default:
3286                 g_assert_not_reached ();
3287         }
3288
3289         init_sgen_minor (minor);
3290         init_sgen_major (major);
3291 }
3292
3293 void
3294 sgen_gc_init (void)
3295 {
3296         char *env;
3297         char **opts, **ptr;
3298         SgenMajor sgen_major = SGEN_MAJOR_DEFAULT;
3299         SgenMinor sgen_minor = SGEN_MINOR_DEFAULT;
3300         SgenMode sgen_mode = SGEN_MODE_NONE;
3301         char *params_opts = NULL;
3302         char *debug_opts = NULL;
3303         size_t max_heap = 0;
3304         size_t soft_limit = 0;
3305         int result;
3306         gboolean debug_print_allowance = FALSE;
3307         double allowance_ratio = 0, save_target = 0;
3308         gboolean cement_enabled = TRUE;
3309
3310         do {
3311                 result = InterlockedCompareExchange (&gc_initialized, -1, 0);
3312                 switch (result) {
3313                 case 1:
3314                         /* already inited */
3315                         return;
3316                 case -1:
3317                         /* being inited by another thread */
3318                         mono_thread_info_usleep (1000);
3319                         break;
3320                 case 0:
3321                         /* we will init it */
3322                         break;
3323                 default:
3324                         g_assert_not_reached ();
3325                 }
3326         } while (result != 0);
3327
3328         SGEN_TV_GETTIME (sgen_init_timestamp);
3329
3330 #ifdef SGEN_WITHOUT_MONO
3331         mono_thread_smr_init ();
3332 #endif
3333
3334         mono_coop_mutex_init (&gc_mutex);
3335
3336         gc_debug_file = stderr;
3337
3338         mono_coop_mutex_init (&sgen_interruption_mutex);
3339
3340         if ((env = g_getenv (MONO_GC_PARAMS_NAME)) || gc_params_options) {
3341                 params_opts = g_strdup_printf ("%s,%s", gc_params_options ? gc_params_options : "", env ? env : "");
3342                 g_free (env);
3343         }
3344
3345         if (params_opts) {
3346                 opts = g_strsplit (params_opts, ",", -1);
3347                 for (ptr = opts; *ptr; ++ptr) {
3348                         char *opt = *ptr;
3349                         if (g_str_has_prefix (opt, "major=")) {
3350                                 opt = strchr (opt, '=') + 1;
3351                                 sgen_major = parse_sgen_major (opt);
3352                         } else if (g_str_has_prefix (opt, "minor=")) {
3353                                 opt = strchr (opt, '=') + 1;
3354                                 sgen_minor = parse_sgen_minor (opt);
3355                         } else if (g_str_has_prefix (opt, "mode=")) {
3356                                 opt = strchr (opt, '=') + 1;
3357                                 sgen_mode = parse_sgen_mode (opt);
3358                         }
3359                 }
3360         } else {
3361                 opts = NULL;
3362         }
3363
3364         init_stats ();
3365         sgen_init_internal_allocator ();
3366         sgen_init_nursery_allocator ();
3367         sgen_init_fin_weak_hash ();
3368         sgen_init_hash_table ();
3369         sgen_init_descriptors ();
3370         sgen_init_gray_queues ();
3371         sgen_init_allocator ();
3372         sgen_init_gchandles ();
3373
3374         sgen_register_fixed_internal_mem_type (INTERNAL_MEM_SECTION, SGEN_SIZEOF_GC_MEM_SECTION);
3375         sgen_register_fixed_internal_mem_type (INTERNAL_MEM_GRAY_QUEUE, sizeof (GrayQueueSection));
3376
3377         sgen_client_init ();
3378
3379         if (sgen_mode != SGEN_MODE_NONE) {
3380                 if (sgen_minor != SGEN_MINOR_DEFAULT || sgen_major != SGEN_MAJOR_DEFAULT)
3381                         sgen_env_var_error (MONO_GC_PARAMS_NAME, "Ignoring major/minor configuration", "Major/minor configurations cannot be used with sgen modes");
3382                 init_sgen_mode (sgen_mode);
3383         } else {
3384                 init_sgen_minor (sgen_minor);
3385                 init_sgen_major (sgen_major);
3386         }
3387
3388         if (opts) {
3389                 gboolean usage_printed = FALSE;
3390
3391                 for (ptr = opts; *ptr; ++ptr) {
3392                         char *opt = *ptr;
3393                         if (!strcmp (opt, ""))
3394                                 continue;
3395                         if (g_str_has_prefix (opt, "major="))
3396                                 continue;
3397                         if (g_str_has_prefix (opt, "minor="))
3398                                 continue;
3399                         if (g_str_has_prefix (opt, "mode=")) {
3400                                 if (g_str_has_prefix (opt, "mode=pause:")) {
3401                                         char *str_pause = strchr (opt, ':') + 1;
3402                                         int pause = atoi (str_pause);
3403                                         if (pause)
3404                                                 sgen_max_pause_time = pause;
3405                                         else
3406                                                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default", "Invalid maximum pause time for `pause` sgen mode");
3407                                 }
3408                                 continue;
3409                         }
3410                         if (g_str_has_prefix (opt, "max-heap-size=")) {
3411                                 size_t page_size = mono_pagesize ();
3412                                 size_t max_heap_candidate = 0;
3413                                 opt = strchr (opt, '=') + 1;
3414                                 if (*opt && mono_gc_parse_environment_string_extract_number (opt, &max_heap_candidate)) {
3415                                         max_heap = (max_heap_candidate + page_size - 1) & ~(size_t)(page_size - 1);
3416                                         if (max_heap != max_heap_candidate)
3417                                                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Rounding up.", "`max-heap-size` size must be a multiple of %d.", page_size);
3418                                 } else {
3419                                         sgen_env_var_error (MONO_GC_PARAMS_NAME, NULL, "`max-heap-size` must be an integer.");
3420                                 }
3421                                 continue;
3422                         }
3423                         if (g_str_has_prefix (opt, "soft-heap-limit=")) {
3424                                 opt = strchr (opt, '=') + 1;
3425                                 if (*opt && mono_gc_parse_environment_string_extract_number (opt, &soft_limit)) {
3426                                         if (soft_limit <= 0) {
3427                                                 sgen_env_var_error (MONO_GC_PARAMS_NAME, NULL, "`soft-heap-limit` must be positive.");
3428                                                 soft_limit = 0;
3429                                         }
3430                                 } else {
3431                                         sgen_env_var_error (MONO_GC_PARAMS_NAME, NULL, "`soft-heap-limit` must be an integer.");
3432                                 }
3433                                 continue;
3434                         }
3435                         if (g_str_has_prefix (opt, "nursery-size=")) {
3436                                 size_t val;
3437                                 opt = strchr (opt, '=') + 1;
3438                                 if (*opt && mono_gc_parse_environment_string_extract_number (opt, &val)) {
3439                                         if ((val & (val - 1))) {
3440                                                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default value.", "`nursery-size` must be a power of two.");
3441                                                 continue;
3442                                         }
3443
3444                                         if (val < SGEN_MAX_NURSERY_WASTE) {
3445                                                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default value.",
3446                                                                 "`nursery-size` must be at least %d bytes.", SGEN_MAX_NURSERY_WASTE);
3447                                                 continue;
3448                                         }
3449
3450                                         min_nursery_size = max_nursery_size = val;
3451                                         dynamic_nursery = FALSE;
3452                                 } else {
3453                                         sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default value.", "`nursery-size` must be an integer.");
3454                                         continue;
3455                                 }
3456                                 continue;
3457                         }
3458                         if (g_str_has_prefix (opt, "save-target-ratio=")) {
3459                                 double val;
3460                                 opt = strchr (opt, '=') + 1;
3461                                 if (parse_double_in_interval (MONO_GC_PARAMS_NAME, "save-target-ratio", opt,
3462                                                 SGEN_MIN_SAVE_TARGET_RATIO, SGEN_MAX_SAVE_TARGET_RATIO, &val)) {
3463                                         save_target = val;
3464                                 }
3465                                 continue;
3466                         }
3467                         if (g_str_has_prefix (opt, "default-allowance-ratio=")) {
3468                                 double val;
3469                                 opt = strchr (opt, '=') + 1;
3470                                 if (parse_double_in_interval (MONO_GC_PARAMS_NAME, "default-allowance-ratio", opt,
3471                                                 SGEN_MIN_ALLOWANCE_NURSERY_SIZE_RATIO, SGEN_MAX_ALLOWANCE_NURSERY_SIZE_RATIO, &val)) {
3472                                         allowance_ratio = val;
3473                                 }
3474                                 continue;
3475                         }
3476
3477                         if (!strcmp (opt, "cementing")) {
3478                                 cement_enabled = TRUE;
3479                                 continue;
3480                         }
3481                         if (!strcmp (opt, "no-cementing")) {
3482                                 cement_enabled = FALSE;
3483                                 continue;
3484                         }
3485
3486                         if (!strcmp (opt, "precleaning")) {
3487                                 precleaning_enabled = TRUE;
3488                                 continue;
3489                         }
3490                         if (!strcmp (opt, "no-precleaning")) {
3491                                 precleaning_enabled = FALSE;
3492                                 continue;
3493                         }
3494
3495                         if (!strcmp (opt, "dynamic-nursery")) {
3496                                 if (sgen_minor_collector.is_split)
3497                                         sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default value.",
3498                                                         "dynamic-nursery not supported with split-nursery.");
3499                                 else
3500                                         dynamic_nursery = TRUE;
3501                                 continue;
3502                         }
3503                         if (!strcmp (opt, "no-dynamic-nursery")) {
3504                                 dynamic_nursery = FALSE;
3505                                 continue;
3506                         }
3507
3508                         if (major_collector.handle_gc_param && major_collector.handle_gc_param (opt))
3509                                 continue;
3510
3511                         if (sgen_minor_collector.handle_gc_param && sgen_minor_collector.handle_gc_param (opt))
3512                                 continue;
3513
3514                         if (sgen_client_handle_gc_param (opt))
3515                                 continue;
3516
3517                         sgen_env_var_error (MONO_GC_PARAMS_NAME, "Ignoring.", "Unknown option `%s`.", opt);
3518
3519                         if (usage_printed)
3520                                 continue;
3521
3522                         fprintf (stderr, "\n%s must be a comma-delimited list of one or more of the following:\n", MONO_GC_PARAMS_NAME);
3523                         fprintf (stderr, "  max-heap-size=N (where N is an integer, possibly with a k, m or a g suffix)\n");
3524                         fprintf (stderr, "  soft-heap-limit=n (where N is an integer, possibly with a k, m or a g suffix)\n");
3525                         fprintf (stderr, "  mode=MODE (where MODE is 'balanced', 'throughput' or 'pause[:N]' and N is maximum pause in milliseconds)\n");
3526                         fprintf (stderr, "  nursery-size=N (where N is an integer, possibly with a k, m or a g suffix)\n");
3527                         fprintf (stderr, "  major=COLLECTOR (where COLLECTOR is `marksweep', `marksweep-conc', `marksweep-par')\n");
3528                         fprintf (stderr, "  minor=COLLECTOR (where COLLECTOR is `simple' or `split')\n");
3529                         fprintf (stderr, "  wbarrier=WBARRIER (where WBARRIER is `remset' or `cardtable')\n");
3530                         fprintf (stderr, "  [no-]cementing\n");
3531                         fprintf (stderr, "  [no-]dynamic-nursery\n");
3532                         if (major_collector.print_gc_param_usage)
3533                                 major_collector.print_gc_param_usage ();
3534                         if (sgen_minor_collector.print_gc_param_usage)
3535                                 sgen_minor_collector.print_gc_param_usage ();
3536                         sgen_client_print_gc_params_usage ();
3537                         fprintf (stderr, " Experimental options:\n");
3538                         fprintf (stderr, "  save-target-ratio=R (where R must be between %.2f - %.2f).\n", SGEN_MIN_SAVE_TARGET_RATIO, SGEN_MAX_SAVE_TARGET_RATIO);
3539                         fprintf (stderr, "  default-allowance-ratio=R (where R must be between %.2f - %.2f).\n", SGEN_MIN_ALLOWANCE_NURSERY_SIZE_RATIO, SGEN_MAX_ALLOWANCE_NURSERY_SIZE_RATIO);
3540                         fprintf (stderr, "\n");
3541
3542                         usage_printed = TRUE;
3543                 }
3544                 g_strfreev (opts);
3545         }
3546
3547         if (params_opts)
3548                 g_free (params_opts);
3549
3550         alloc_nursery (dynamic_nursery, min_nursery_size, max_nursery_size);
3551
3552         sgen_pinning_init ();
3553         sgen_cement_init (cement_enabled);
3554
3555         if ((env = g_getenv (MONO_GC_DEBUG_NAME)) || gc_debug_options) {
3556                 debug_opts = g_strdup_printf ("%s,%s", gc_debug_options ? gc_debug_options  : "", env ? env : "");
3557                 g_free (env);
3558         }
3559
3560         if (debug_opts) {
3561                 gboolean usage_printed = FALSE;
3562
3563                 opts = g_strsplit (debug_opts, ",", -1);
3564                 for (ptr = opts; ptr && *ptr; ptr ++) {
3565                         char *opt = *ptr;
3566                         if (!strcmp (opt, ""))
3567                                 continue;
3568                         if (opt [0] >= '0' && opt [0] <= '9') {
3569                                 gc_debug_level = atoi (opt);
3570                                 opt++;
3571                                 if (opt [0] == ':')
3572                                         opt++;
3573                                 if (opt [0]) {
3574                                         char *rf = g_strdup_printf ("%s.%d", opt, mono_process_current_pid ());
3575                                         gc_debug_file = fopen (rf, "wb");
3576                                         if (!gc_debug_file)
3577                                                 gc_debug_file = stderr;
3578                                         g_free (rf);
3579                                 }
3580                         } else if (!strcmp (opt, "print-allowance")) {
3581                                 debug_print_allowance = TRUE;
3582                         } else if (!strcmp (opt, "print-pinning")) {
3583                                 sgen_pin_stats_enable ();
3584                         } else if (!strcmp (opt, "verify-before-allocs")) {
3585                                 verify_before_allocs = 1;
3586                                 has_per_allocation_action = TRUE;
3587                         } else if (g_str_has_prefix (opt, "max-valloc-size=")) {
3588                                 size_t max_valloc_size;
3589                                 char *arg = strchr (opt, '=') + 1;
3590                                 if (*opt && mono_gc_parse_environment_string_extract_number (arg, &max_valloc_size)) {
3591                                         mono_valloc_set_limit (max_valloc_size);
3592                                 } else {
3593                                         sgen_env_var_error (MONO_GC_DEBUG_NAME, NULL, "`max-valloc-size` must be an integer.");
3594                                 }
3595                                 continue;
3596                         } else if (g_str_has_prefix (opt, "verify-before-allocs=")) {
3597                                 char *arg = strchr (opt, '=') + 1;
3598                                 verify_before_allocs = atoi (arg);
3599                                 has_per_allocation_action = TRUE;
3600                         } else if (!strcmp (opt, "collect-before-allocs")) {
3601                                 collect_before_allocs = 1;
3602                                 has_per_allocation_action = TRUE;
3603                         } else if (g_str_has_prefix (opt, "collect-before-allocs=")) {
3604                                 char *arg = strchr (opt, '=') + 1;
3605                                 has_per_allocation_action = TRUE;
3606                                 collect_before_allocs = atoi (arg);
3607                         } else if (!strcmp (opt, "verify-before-collections")) {
3608                                 whole_heap_check_before_collection = TRUE;
3609                         } else if (!strcmp (opt, "check-remset-consistency")) {
3610                                 remset_consistency_checks = TRUE;
3611                                 nursery_clear_policy = CLEAR_AT_GC;
3612                         } else if (!strcmp (opt, "mod-union-consistency-check")) {
3613                                 if (!major_collector.is_concurrent) {
3614                                         sgen_env_var_error (MONO_GC_DEBUG_NAME, "Ignoring.", "`mod-union-consistency-check` only works with concurrent major collector.");
3615                                         continue;
3616                                 }
3617                                 mod_union_consistency_check = TRUE;
3618                         } else if (!strcmp (opt, "check-mark-bits")) {
3619                                 check_mark_bits_after_major_collection = TRUE;
3620                         } else if (!strcmp (opt, "check-nursery-pinned")) {
3621                                 check_nursery_objects_pinned = TRUE;
3622                         } else if (!strcmp (opt, "clear-at-gc")) {
3623                                 nursery_clear_policy = CLEAR_AT_GC;
3624                         } else if (!strcmp (opt, "clear-nursery-at-gc")) {
3625                                 nursery_clear_policy = CLEAR_AT_GC;
3626                         } else if (!strcmp (opt, "clear-at-tlab-creation")) {
3627                                 nursery_clear_policy = CLEAR_AT_TLAB_CREATION;
3628                         } else if (!strcmp (opt, "debug-clear-at-tlab-creation")) {
3629                                 nursery_clear_policy = CLEAR_AT_TLAB_CREATION_DEBUG;
3630                         } else if (!strcmp (opt, "check-scan-starts")) {
3631                                 do_scan_starts_check = TRUE;
3632                         } else if (!strcmp (opt, "verify-nursery-at-minor-gc")) {
3633                                 do_verify_nursery = TRUE;
3634                         } else if (!strcmp (opt, "check-concurrent")) {
3635                                 if (!major_collector.is_concurrent) {
3636                                         sgen_env_var_error (MONO_GC_DEBUG_NAME, "Ignoring.", "`check-concurrent` only works with concurrent major collectors.");
3637                                         continue;
3638                                 }
3639                                 nursery_clear_policy = CLEAR_AT_GC;
3640                                 do_concurrent_checks = TRUE;
3641                         } else if (!strcmp (opt, "dump-nursery-at-minor-gc")) {
3642                                 do_dump_nursery_content = TRUE;
3643                         } else if (!strcmp (opt, "disable-minor")) {
3644                                 disable_minor_collections = TRUE;
3645                         } else if (!strcmp (opt, "disable-major")) {
3646                                 disable_major_collections = TRUE;
3647                         } else if (g_str_has_prefix (opt, "heap-dump=")) {
3648                                 char *filename = strchr (opt, '=') + 1;
3649                                 nursery_clear_policy = CLEAR_AT_GC;
3650                                 sgen_debug_enable_heap_dump (filename);
3651                         } else if (g_str_has_prefix (opt, "binary-protocol=")) {
3652                                 char *filename = strchr (opt, '=') + 1;
3653                                 char *colon = strrchr (filename, ':');
3654                                 size_t limit = 0;
3655                                 if (colon) {
3656                                         if (!mono_gc_parse_environment_string_extract_number (colon + 1, &limit)) {
3657                                                 sgen_env_var_error (MONO_GC_DEBUG_NAME, "Ignoring limit.", "Binary protocol file size limit must be an integer.");
3658                                                 limit = -1;
3659                                         }
3660                                         *colon = '\0';
3661                                 }
3662                                 binary_protocol_init (filename, (long long)limit);
3663                         } else if (!strcmp (opt, "nursery-canaries")) {
3664                                 do_verify_nursery = TRUE;
3665                                 enable_nursery_canaries = TRUE;
3666                         } else if (!sgen_client_handle_gc_debug (opt)) {
3667                                 sgen_env_var_error (MONO_GC_DEBUG_NAME, "Ignoring.", "Unknown option `%s`.", opt);
3668
3669                                 if (usage_printed)
3670                                         continue;
3671
3672                                 fprintf (stderr, "\n%s must be of the format [<l>[:<filename>]|<option>]+ where <l> is a debug level 0-9.\n", MONO_GC_DEBUG_NAME);
3673                                 fprintf (stderr, "Valid <option>s are:\n");
3674                                 fprintf (stderr, "  collect-before-allocs[=<n>]\n");
3675                                 fprintf (stderr, "  verify-before-allocs[=<n>]\n");
3676                                 fprintf (stderr, "  max-valloc-size=N (where N is an integer, possibly with a k, m or a g suffix)\n");
3677                                 fprintf (stderr, "  check-remset-consistency\n");
3678                                 fprintf (stderr, "  check-mark-bits\n");
3679                                 fprintf (stderr, "  check-nursery-pinned\n");
3680                                 fprintf (stderr, "  verify-before-collections\n");
3681                                 fprintf (stderr, "  verify-nursery-at-minor-gc\n");
3682                                 fprintf (stderr, "  dump-nursery-at-minor-gc\n");
3683                                 fprintf (stderr, "  disable-minor\n");
3684                                 fprintf (stderr, "  disable-major\n");
3685                                 fprintf (stderr, "  check-concurrent\n");
3686                                 fprintf (stderr, "  clear-[nursery-]at-gc\n");
3687                                 fprintf (stderr, "  clear-at-tlab-creation\n");
3688                                 fprintf (stderr, "  debug-clear-at-tlab-creation\n");
3689                                 fprintf (stderr, "  check-scan-starts\n");
3690                                 fprintf (stderr, "  print-allowance\n");
3691                                 fprintf (stderr, "  print-pinning\n");
3692                                 fprintf (stderr, "  heap-dump=<filename>\n");
3693                                 fprintf (stderr, "  binary-protocol=<filename>[:<file-size-limit>]\n");
3694                                 fprintf (stderr, "  nursery-canaries\n");
3695                                 sgen_client_print_gc_debug_usage ();
3696                                 fprintf (stderr, "\n");
3697
3698                                 usage_printed = TRUE;
3699                         }
3700                 }
3701                 g_strfreev (opts);
3702         }
3703
3704         if (debug_opts)
3705                 g_free (debug_opts);
3706
3707         if (check_mark_bits_after_major_collection)
3708                 nursery_clear_policy = CLEAR_AT_GC;
3709
3710         if (major_collector.post_param_init)
3711                 major_collector.post_param_init (&major_collector);
3712
3713         sgen_thread_pool_start ();
3714
3715         sgen_memgov_init (max_heap, soft_limit, debug_print_allowance, allowance_ratio, save_target);
3716
3717         memset (&remset, 0, sizeof (remset));
3718
3719         sgen_card_table_init (&remset);
3720
3721         sgen_register_root (NULL, 0, sgen_make_user_root_descriptor (sgen_mark_normal_gc_handles), ROOT_TYPE_NORMAL, MONO_ROOT_SOURCE_GC_HANDLE, "normal gc handles");
3722
3723         gc_initialized = 1;
3724
3725         sgen_init_bridge ();
3726 }
3727
3728 gboolean
3729 sgen_gc_initialized ()
3730 {
3731         return gc_initialized > 0;
3732 }
3733
3734 NurseryClearPolicy
3735 sgen_get_nursery_clear_policy (void)
3736 {
3737         return nursery_clear_policy;
3738 }
3739
3740 void
3741 sgen_gc_lock (void)
3742 {
3743         mono_coop_mutex_lock (&gc_mutex);
3744 }
3745
3746 void
3747 sgen_gc_unlock (void)
3748 {
3749         mono_coop_mutex_unlock (&gc_mutex);
3750 }
3751
3752 void
3753 sgen_major_collector_iterate_live_block_ranges (sgen_cardtable_block_callback callback)
3754 {
3755         major_collector.iterate_live_block_ranges (callback);
3756 }
3757
3758 void
3759 sgen_major_collector_iterate_block_ranges (sgen_cardtable_block_callback callback)
3760 {
3761         major_collector.iterate_block_ranges (callback);
3762 }
3763
3764 SgenMajorCollector*
3765 sgen_get_major_collector (void)
3766 {
3767         return &major_collector;
3768 }
3769
3770 SgenMinorCollector*
3771 sgen_get_minor_collector (void)
3772 {
3773         return &sgen_minor_collector;
3774 }
3775
3776 SgenRememberedSet*
3777 sgen_get_remset (void)
3778 {
3779         return &remset;
3780 }
3781
3782 static void
3783 count_cards (long long *major_total, long long *major_marked, long long *los_total, long long *los_marked)
3784 {
3785         sgen_get_major_collector ()->count_cards (major_total, major_marked);
3786         sgen_los_count_cards (los_total, los_marked);
3787 }
3788
3789 static gboolean world_is_stopped = FALSE;
3790
3791 /* LOCKING: assumes the GC lock is held */
3792 void
3793 sgen_stop_world (int generation)
3794 {
3795         long long major_total = -1, major_marked = -1, los_total = -1, los_marked = -1;
3796
3797         SGEN_ASSERT (0, !world_is_stopped, "Why are we stopping a stopped world?");
3798
3799         binary_protocol_world_stopping (generation, sgen_timestamp (), (gpointer) (gsize) mono_native_thread_id_get ());
3800
3801         sgen_client_stop_world (generation);
3802
3803         world_is_stopped = TRUE;
3804
3805         if (binary_protocol_is_heavy_enabled ())
3806                 count_cards (&major_total, &major_marked, &los_total, &los_marked);
3807         binary_protocol_world_stopped (generation, sgen_timestamp (), major_total, major_marked, los_total, los_marked);
3808 }
3809
3810 /* LOCKING: assumes the GC lock is held */
3811 void
3812 sgen_restart_world (int generation)
3813 {
3814         long long major_total = -1, major_marked = -1, los_total = -1, los_marked = -1;
3815         gint64 stw_time;
3816
3817         SGEN_ASSERT (0, world_is_stopped, "Why are we restarting a running world?");
3818
3819         if (binary_protocol_is_heavy_enabled ())
3820                 count_cards (&major_total, &major_marked, &los_total, &los_marked);
3821         binary_protocol_world_restarting (generation, sgen_timestamp (), major_total, major_marked, los_total, los_marked);
3822
3823         world_is_stopped = FALSE;
3824
3825         sgen_client_restart_world (generation, &stw_time);
3826
3827         binary_protocol_world_restarted (generation, sgen_timestamp ());
3828
3829         if (sgen_client_bridge_need_processing ())
3830                 sgen_client_bridge_processing_finish (generation);
3831
3832         sgen_memgov_collection_end (generation, stw_time);
3833 }
3834
3835 gboolean
3836 sgen_is_world_stopped (void)
3837 {
3838         return world_is_stopped;
3839 }
3840
3841 void
3842 sgen_check_whole_heap_stw (void)
3843 {
3844         sgen_stop_world (0);
3845         sgen_clear_nursery_fragments ();
3846         sgen_check_whole_heap (TRUE);
3847         sgen_restart_world (0);
3848 }
3849
3850 gint64
3851 sgen_timestamp (void)
3852 {
3853         SGEN_TV_DECLARE (timestamp);
3854         SGEN_TV_GETTIME (timestamp);
3855         return SGEN_TV_ELAPSED (sgen_init_timestamp, timestamp);
3856 }
3857
3858 #endif /* HAVE_SGEN_GC */