mono/metadata/sgen-gc.c

   1 /*
   2  * sgen-gc.c: Simple generational GC.
   3  *
   4  * Author:
   5  *      Paolo Molaro (lupus@ximian.com)
   6  *  Rodrigo Kumpera (kumpera@gmail.com)
   7  *
   8  * Copyright 2005-2011 Novell, Inc (http://www.novell.com)
   9  * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
  10  *
  11  * Thread start/stop adapted from Boehm's GC:
  12  * Copyright (c) 1994 by Xerox Corporation.  All rights reserved.
  13  * Copyright (c) 1996 by Silicon Graphics.  All rights reserved.
  14  * Copyright (c) 1998 by Fergus Henderson.  All rights reserved.
  15  * Copyright (c) 2000-2004 by Hewlett-Packard Company.  All rights reserved.
  16  * Copyright 2001-2003 Ximian, Inc
  17  * Copyright 2003-2010 Novell, Inc.
  18  * Copyright 2011 Xamarin, Inc.
  19  * Copyright (C) 2012 Xamarin Inc
  20  *
  21  * This library is free software; you can redistribute it and/or
  22  * modify it under the terms of the GNU Library General Public
  23  * License 2.0 as published by the Free Software Foundation;
  24  *
  25  * This library is distributed in the hope that it will be useful,
  26  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  27  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  28  * Library General Public License for more details.
  29  *
  30  * You should have received a copy of the GNU Library General Public
  31  * License 2.0 along with this library; if not, write to the Free
  32  * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  33  *
  34  * Important: allocation provides always zeroed memory, having to do
  35  * a memset after allocation is deadly for performance.
  36  * Memory usage at startup is currently as follows:
  37  * 64 KB pinned space
  38  * 64 KB internal space
  39  * size of nursery
  40  * We should provide a small memory config with half the sizes
  41  *
  42  * We currently try to make as few mono assumptions as possible:
  43  * 1) 2-word header with no GC pointers in it (first vtable, second to store the
  44  *    forwarding ptr)
  45  * 2) gc descriptor is the second word in the vtable (first word in the class)
  46  * 3) 8 byte alignment is the minimum and enough (not true for special structures (SIMD), FIXME)
  47  * 4) there is a function to get an object's size and the number of
  48  *    elements in an array.
  49  * 5) we know the special way bounds are allocated for complex arrays
  50  * 6) we know about proxies and how to treat them when domains are unloaded
  51  *
  52  * Always try to keep stack usage to a minimum: no recursive behaviour
  53  * and no large stack allocs.
  54  *
  55  * General description.
  56  * Objects are initially allocated in a nursery using a fast bump-pointer technique.
  57  * When the nursery is full we start a nursery collection: this is performed with a
  58  * copying GC.
  59  * When the old generation is full we start a copying GC of the old generation as well:
  60  * this will be changed to mark&sweep with copying when fragmentation becomes to severe
  61  * in the future.  Maybe we'll even do both during the same collection like IMMIX.
  62  *
  63  * The things that complicate this description are:
  64  * *) pinned objects: we can't move them so we need to keep track of them
  65  * *) no precise info of the thread stacks and registers: we need to be able to
  66  *    quickly find the objects that may be referenced conservatively and pin them
  67  *    (this makes the first issues more important)
  68  * *) large objects are too expensive to be dealt with using copying GC: we handle them
  69  *    with mark/sweep during major collections
  70  * *) some objects need to not move even if they are small (interned strings, Type handles):
  71  *    we use mark/sweep for them, too: they are not allocated in the nursery, but inside
  72  *    PinnedChunks regions
  73  */
  74
  75 /*
  76  * TODO:
  77
  78  *) we could have a function pointer in MonoClass to implement
  79   customized write barriers for value types
  80
  81  *) investigate the stuff needed to advance a thread to a GC-safe
  82   point (single-stepping, read from unmapped memory etc) and implement it.
  83   This would enable us to inline allocations and write barriers, for example,
  84   or at least parts of them, like the write barrier checks.
  85   We may need this also for handling precise info on stacks, even simple things
  86   as having uninitialized data on the stack and having to wait for the prolog
  87   to zero it. Not an issue for the last frame that we scan conservatively.
  88   We could always not trust the value in the slots anyway.
  89
  90  *) modify the jit to save info about references in stack locations:
  91   this can be done just for locals as a start, so that at least
  92   part of the stack is handled precisely.
  93
  94  *) test/fix endianess issues
  95
  96  *) Implement a card table as the write barrier instead of remembered
  97     sets?  Card tables are not easy to implement with our current
  98     memory layout.  We have several different kinds of major heap
  99     objects: Small objects in regular blocks, small objects in pinned
 100     chunks and LOS objects.  If we just have a pointer we have no way
 101     to tell which kind of object it points into, therefore we cannot
 102     know where its card table is.  The least we have to do to make
 103     this happen is to get rid of write barriers for indirect stores.
 104     (See next item)
 105
 106  *) Get rid of write barriers for indirect stores.  We can do this by
 107     telling the GC to wbarrier-register an object once we do an ldloca
 108     or ldelema on it, and to unregister it once it's not used anymore
 109     (it can only travel downwards on the stack).  The problem with
 110     unregistering is that it needs to happen eventually no matter
 111     what, even if exceptions are thrown, the thread aborts, etc.
 112     Rodrigo suggested that we could do only the registering part and
 113     let the collector find out (pessimistically) when it's safe to
 114     unregister, namely when the stack pointer of the thread that
 115     registered the object is higher than it was when the registering
 116     happened.  This might make for a good first implementation to get
 117     some data on performance.
 118
 119  *) Some sort of blacklist support?  Blacklists is a concept from the
 120     Boehm GC: if during a conservative scan we find pointers to an
 121     area which we might use as heap, we mark that area as unusable, so
 122     pointer retention by random pinning pointers is reduced.
 123
 124  *) experiment with max small object size (very small right now - 2kb,
 125     because it's tied to the max freelist size)
 126
 127   *) add an option to mmap the whole heap in one chunk: it makes for many
 128      simplifications in the checks (put the nursery at the top and just use a single
 129      check for inclusion/exclusion): the issue this has is that on 32 bit systems it's
 130      not flexible (too much of the address space may be used by default or we can't
 131      increase the heap as needed) and we'd need a race-free mechanism to return memory
 132      back to the system (mprotect(PROT_NONE) will still keep the memory allocated if it
 133      was written to, munmap is needed, but the following mmap may not find the same segment
 134      free...)
 135
 136  *) memzero the major fragments after restarting the world and optionally a smaller
 137     chunk at a time
 138
 139  *) investigate having fragment zeroing threads
 140
 141  *) separate locks for finalization and other minor stuff to reduce
 142     lock contention
 143
 144  *) try a different copying order to improve memory locality
 145
 146  *) a thread abort after a store but before the write barrier will
 147     prevent the write barrier from executing
 148
 149  *) specialized dynamically generated markers/copiers
 150
 151  *) Dynamically adjust TLAB size to the number of threads.  If we have
 152     too many threads that do allocation, we might need smaller TLABs,
 153     and we might get better performance with larger TLABs if we only
 154     have a handful of threads.  We could sum up the space left in all
 155     assigned TLABs and if that's more than some percentage of the
 156     nursery size, reduce the TLAB size.
 157
 158  *) Explore placing unreachable objects on unused nursery memory.
 159         Instead of memset'ng a region to zero, place an int[] covering it.
 160         A good place to start is add_nursery_frag. The tricky thing here is
 161         placing those objects atomically outside of a collection.
 162
 163  *) Allocation should use asymmetric Dekker synchronization:
 164         http://blogs.oracle.com/dave/resource/Asymmetric-Dekker-Synchronization.txt
 165         This should help weak consistency archs.
 166  */
 167 #include "config.h"
 168 #ifdef HAVE_SGEN_GC
 169
 170 #ifdef __MACH__
 171 #undef _XOPEN_SOURCE
 172 #define _XOPEN_SOURCE
 173 #define _DARWIN_C_SOURCE
 174 #endif
 175
 176 #ifdef HAVE_UNISTD_H
 177 #include <unistd.h>
 178 #endif
 179 #ifdef HAVE_PTHREAD_H
 180 #include <pthread.h>
 181 #endif
 182 #ifdef HAVE_PTHREAD_NP_H
 183 #include <pthread_np.h>
 184 #endif
 185 #ifdef HAVE_SEMAPHORE_H
 186 #include <semaphore.h>
 187 #endif
 188 #include <stdio.h>
 189 #include <string.h>
 190 #include <errno.h>
 191 #include <assert.h>
 192
 193 #include "metadata/sgen-gc.h"
 194 #include "metadata/metadata-internals.h"
 195 #include "metadata/class-internals.h"
 196 #include "metadata/gc-internal.h"
 197 #include "metadata/object-internals.h"
 198 #include "metadata/threads.h"
 199 #include "metadata/sgen-cardtable.h"
 200 #include "metadata/sgen-protocol.h"
 201 #include "metadata/sgen-archdep.h"
 202 #include "metadata/sgen-bridge.h"
 203 #include "metadata/sgen-memory-governor.h"
 204 #include "metadata/sgen-hash-table.h"
 205 #include "metadata/mono-gc.h"
 206 #include "metadata/method-builder.h"
 207 #include "metadata/profiler-private.h"
 208 #include "metadata/monitor.h"
 209 #include "metadata/mempool-internals.h"
 210 #include "metadata/marshal.h"
 211 #include "metadata/runtime.h"
 212 #include "metadata/sgen-cardtable.h"
 213 #include "metadata/sgen-pinning.h"
 214 #include "metadata/sgen-workers.h"
 215 #include "metadata/sgen-layout-stats.h"
 216 #include "utils/mono-mmap.h"
 217 #include "utils/mono-time.h"
 218 #include "utils/mono-semaphore.h"
 219 #include "utils/mono-counters.h"
 220 #include "utils/mono-proclib.h"
 221 #include "utils/mono-memory-model.h"
 222 #include "utils/mono-logger-internal.h"
 223 #include "utils/dtrace.h"
 224
 225 #include <mono/utils/mono-logger-internal.h>
 226 #include <mono/utils/memcheck.h>
 227
 228 #if defined(__MACH__)
 229 #include "utils/mach-support.h"
 230 #endif
 231
 232 #define OPDEF(a,b,c,d,e,f,g,h,i,j) \
 233         a = i,
 234
 235 enum {
 236 #include "mono/cil/opcode.def"
 237         CEE_LAST
 238 };
 239
 240 #undef OPDEF
 241
 242 #undef pthread_create
 243 #undef pthread_join
 244 #undef pthread_detach
 245
 246 /*
 247  * ######################################################################
 248  * ########  Types and constants used by the GC.
 249  * ######################################################################
 250  */
 251
 252 /* 0 means not initialized, 1 is initialized, -1 means in progress */
 253 static int gc_initialized = 0;
 254 /* If set, check if we need to do something every X allocations */
 255 gboolean has_per_allocation_action;
 256 /* If set, do a heap check every X allocation */
 257 guint32 verify_before_allocs = 0;
 258 /* If set, do a minor collection before every X allocation */
 259 guint32 collect_before_allocs = 0;
 260 /* If set, do a whole heap check before each collection */
 261 static gboolean whole_heap_check_before_collection = FALSE;
 262 /* If set, do a heap consistency check before each minor collection */
 263 static gboolean consistency_check_at_minor_collection = FALSE;
 264 /* If set, do a mod union consistency check before each finishing collection pause */
 265 static gboolean mod_union_consistency_check = FALSE;
 266 /* If set, check whether mark bits are consistent after major collections */
 267 static gboolean check_mark_bits_after_major_collection = FALSE;
 268 /* If set, check that all nursery objects are pinned/not pinned, depending on context */
 269 static gboolean check_nursery_objects_pinned = FALSE;
 270 /* If set, do a few checks when the concurrent collector is used */
 271 static gboolean do_concurrent_checks = FALSE;
 272 /* If set, check that there are no references to the domain left at domain unload */
 273 static gboolean xdomain_checks = FALSE;
 274 /* If not null, dump the heap after each collection into this file */
 275 static FILE *heap_dump_file = NULL;
 276 /* If set, mark stacks conservatively, even if precise marking is possible */
 277 static gboolean conservative_stack_mark = FALSE;
 278 /* If set, do a plausibility check on the scan_starts before and after
 279    each collection */
 280 static gboolean do_scan_starts_check = FALSE;
 281
 282 /*
 283  * If the major collector is concurrent and this is FALSE, we will
 284  * never initiate a synchronous major collection, unless requested via
 285  * GC.Collect().
 286  */
 287 static gboolean allow_synchronous_major = TRUE;
 288 static gboolean disable_minor_collections = FALSE;
 289 static gboolean disable_major_collections = FALSE;
 290 static gboolean do_verify_nursery = FALSE;
 291 static gboolean do_dump_nursery_content = FALSE;
 292 static gboolean enable_nursery_canaries = FALSE;
 293
 294 #ifdef HEAVY_STATISTICS
 295 guint64 stat_objects_alloced_degraded = 0;
 296 guint64 stat_bytes_alloced_degraded = 0;
 297
 298 guint64 stat_copy_object_called_nursery = 0;
 299 guint64 stat_objects_copied_nursery = 0;
 300 guint64 stat_copy_object_called_major = 0;
 301 guint64 stat_objects_copied_major = 0;
 302
 303 guint64 stat_scan_object_called_nursery = 0;
 304 guint64 stat_scan_object_called_major = 0;
 305
 306 guint64 stat_slots_allocated_in_vain;
 307
 308 guint64 stat_nursery_copy_object_failed_from_space = 0;
 309 guint64 stat_nursery_copy_object_failed_forwarded = 0;
 310 guint64 stat_nursery_copy_object_failed_pinned = 0;
 311 guint64 stat_nursery_copy_object_failed_to_space = 0;
 312
 313 static int stat_wbarrier_add_to_global_remset = 0;
 314 static int stat_wbarrier_set_field = 0;
 315 static int stat_wbarrier_set_arrayref = 0;
 316 static int stat_wbarrier_arrayref_copy = 0;
 317 static int stat_wbarrier_generic_store = 0;
 318 static int stat_wbarrier_generic_store_atomic = 0;
 319 static int stat_wbarrier_set_root = 0;
 320 static int stat_wbarrier_value_copy = 0;
 321 static int stat_wbarrier_object_copy = 0;
 322 #endif
 323
 324 static guint64 stat_pinned_objects = 0;
 325
 326 static guint64 time_minor_pre_collection_fragment_clear = 0;
 327 static guint64 time_minor_pinning = 0;
 328 static guint64 time_minor_scan_remsets = 0;
 329 static guint64 time_minor_scan_pinned = 0;
 330 static guint64 time_minor_scan_roots = 0;
 331 static guint64 time_minor_finish_gray_stack = 0;
 332 static guint64 time_minor_fragment_creation = 0;
 333
 334 static guint64 time_major_pre_collection_fragment_clear = 0;
 335 static guint64 time_major_pinning = 0;
 336 static guint64 time_major_scan_pinned = 0;
 337 static guint64 time_major_scan_roots = 0;
 338 static guint64 time_major_scan_mod_union = 0;
 339 static guint64 time_major_finish_gray_stack = 0;
 340 static guint64 time_major_free_bigobjs = 0;
 341 static guint64 time_major_los_sweep = 0;
 342 static guint64 time_major_sweep = 0;
 343 static guint64 time_major_fragment_creation = 0;
 344
 345 static guint64 time_max = 0;
 346
 347 static SGEN_TV_DECLARE (time_major_conc_collection_start);
 348 static SGEN_TV_DECLARE (time_major_conc_collection_end);
 349
 350 static SGEN_TV_DECLARE (last_minor_collection_start_tv);
 351 static SGEN_TV_DECLARE (last_minor_collection_end_tv);
 352
 353 int gc_debug_level = 0;
 354 FILE* gc_debug_file;
 355
 356 static MonoGCFinalizerCallbacks fin_callbacks;
 357
 358 /*
 359 void
 360 mono_gc_flush_info (void)
 361 {
 362         fflush (gc_debug_file);
 363 }
 364 */
 365
 366 #define TV_DECLARE SGEN_TV_DECLARE
 367 #define TV_GETTIME SGEN_TV_GETTIME
 368 #define TV_ELAPSED SGEN_TV_ELAPSED
 369
 370 SGEN_TV_DECLARE (sgen_init_timestamp);
 371
 372 #define ALIGN_TO(val,align) ((((guint64)val) + ((align) - 1)) & ~((align) - 1))
 373
 374 NurseryClearPolicy nursery_clear_policy = CLEAR_AT_TLAB_CREATION;
 375
 376 #define object_is_forwarded     SGEN_OBJECT_IS_FORWARDED
 377 #define object_is_pinned        SGEN_OBJECT_IS_PINNED
 378 #define pin_object              SGEN_PIN_OBJECT
 379
 380 #define ptr_in_nursery sgen_ptr_in_nursery
 381
 382 #define LOAD_VTABLE     SGEN_LOAD_VTABLE
 383
 384 static const char*
 385 safe_name (void* obj)
 386 {
 387         MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (obj);
 388         return vt->klass->name;
 389 }
 390
 391 gboolean
 392 nursery_canaries_enabled (void)
 393 {
 394         return enable_nursery_canaries;
 395 }
 396
 397 #define safe_object_get_size    sgen_safe_object_get_size
 398
 399 const char*
 400 sgen_safe_name (void* obj)
 401 {
 402         return safe_name (obj);
 403 }
 404
 405 /*
 406  * ######################################################################
 407  * ########  Global data.
 408  * ######################################################################
 409  */
 410 LOCK_DECLARE (gc_mutex);
 411 gboolean sgen_try_free_some_memory;
 412
 413 #define SCAN_START_SIZE SGEN_SCAN_START_SIZE
 414
 415 static mword pagesize = 4096;
 416 size_t degraded_mode = 0;
 417
 418 static mword bytes_pinned_from_failed_allocation = 0;
 419
 420 GCMemSection *nursery_section = NULL;
 421 static volatile mword lowest_heap_address = ~(mword)0;
 422 static volatile mword highest_heap_address = 0;
 423
 424 LOCK_DECLARE (sgen_interruption_mutex);
 425
 426 typedef struct _FinalizeReadyEntry FinalizeReadyEntry;
 427 struct _FinalizeReadyEntry {
 428         FinalizeReadyEntry *next;
 429         void *object;
 430 };
 431
 432 typedef struct _EphemeronLinkNode EphemeronLinkNode;
 433
 434 struct _EphemeronLinkNode {
 435         EphemeronLinkNode *next;
 436         char *array;
 437 };
 438
 439 typedef struct {
 440        void *key;
 441        void *value;
 442 } Ephemeron;
 443
 444 int current_collection_generation = -1;
 445 volatile gboolean concurrent_collection_in_progress = FALSE;
 446
 447 /* objects that are ready to be finalized */
 448 static FinalizeReadyEntry *fin_ready_list = NULL;
 449 static FinalizeReadyEntry *critical_fin_list = NULL;
 450
 451 static EphemeronLinkNode *ephemeron_list;
 452
 453 /* registered roots: the key to the hash is the root start address */
 454 /*
 455  * Different kinds of roots are kept separate to speed up pin_from_roots () for example.
 456  */
 457 SgenHashTable roots_hash [ROOT_TYPE_NUM] = {
 458         SGEN_HASH_TABLE_INIT (INTERNAL_MEM_ROOTS_TABLE, INTERNAL_MEM_ROOT_RECORD, sizeof (RootRecord), mono_aligned_addr_hash, NULL),
 459         SGEN_HASH_TABLE_INIT (INTERNAL_MEM_ROOTS_TABLE, INTERNAL_MEM_ROOT_RECORD, sizeof (RootRecord), mono_aligned_addr_hash, NULL),
 460         SGEN_HASH_TABLE_INIT (INTERNAL_MEM_ROOTS_TABLE, INTERNAL_MEM_ROOT_RECORD, sizeof (RootRecord), mono_aligned_addr_hash, NULL)
 461 };
 462 static mword roots_size = 0; /* amount of memory in the root set */
 463
 464 #define GC_ROOT_NUM 32
 465 typedef struct {
 466         int count;              /* must be the first field */
 467         void *objects [GC_ROOT_NUM];
 468         int root_types [GC_ROOT_NUM];
 469         uintptr_t extra_info [GC_ROOT_NUM];
 470 } GCRootReport;
 471
 472 static void
 473 notify_gc_roots (GCRootReport *report)
 474 {
 475         if (!report->count)
 476                 return;
 477         mono_profiler_gc_roots (report->count, report->objects, report->root_types, report->extra_info);
 478         report->count = 0;
 479 }
 480
 481 static void
 482 add_profile_gc_root (GCRootReport *report, void *object, int rtype, uintptr_t extra_info)
 483 {
 484         if (report->count == GC_ROOT_NUM)
 485                 notify_gc_roots (report);
 486         report->objects [report->count] = object;
 487         report->root_types [report->count] = rtype;
 488         report->extra_info [report->count++] = (uintptr_t)((MonoVTable*)LOAD_VTABLE (object))->klass;
 489 }
 490
 491 MonoNativeTlsKey thread_info_key;
 492
 493 #ifdef HAVE_KW_THREAD
 494 __thread SgenThreadInfo *sgen_thread_info;
 495 __thread char *stack_end;
 496 #endif
 497
 498 /* The size of a TLAB */
 499 /* The bigger the value, the less often we have to go to the slow path to allocate a new
 500  * one, but the more space is wasted by threads not allocating much memory.
 501  * FIXME: Tune this.
 502  * FIXME: Make this self-tuning for each thread.
 503  */
 504 guint32 tlab_size = (1024 * 4);
 505
 506 #define MAX_SMALL_OBJ_SIZE      SGEN_MAX_SMALL_OBJ_SIZE
 507
 508 /* Functions supplied by the runtime to be called by the GC */
 509 static MonoGCCallbacks gc_callbacks;
 510
 511 #define ALLOC_ALIGN             SGEN_ALLOC_ALIGN
 512
 513 #define ALIGN_UP                SGEN_ALIGN_UP
 514
 515 #define MOVED_OBJECTS_NUM 64
 516 static void *moved_objects [MOVED_OBJECTS_NUM];
 517 static int moved_objects_idx = 0;
 518
 519 /* Vtable of the objects used to fill out nursery fragments before a collection */
 520 static MonoVTable *array_fill_vtable;
 521
 522 #ifdef SGEN_DEBUG_INTERNAL_ALLOC
 523 MonoNativeThreadId main_gc_thread = NULL;
 524 #endif
 525
 526 /*Object was pinned during the current collection*/
 527 static mword objects_pinned;
 528
 529 /*
 530  * ######################################################################
 531  * ########  Macros and function declarations.
 532  * ######################################################################
 533  */
 534
 535 typedef SgenGrayQueue GrayQueue;
 536
 537 /* forward declarations */
 538 static void scan_thread_data (void *start_nursery, void *end_nursery, gboolean precise, ScanCopyContext ctx);
 539 static void scan_from_registered_roots (char *addr_start, char *addr_end, int root_type, ScanCopyContext ctx);
 540 static void scan_finalizer_entries (FinalizeReadyEntry *list, ScanCopyContext ctx);
 541 static void report_finalizer_roots (void);
 542 static void report_registered_roots (void);
 543
 544 static void pin_from_roots (void *start_nursery, void *end_nursery, ScanCopyContext ctx);
 545 static void finish_gray_stack (int generation, ScanCopyContext ctx);
 546
 547 void mono_gc_scan_for_specific_ref (MonoObject *key, gboolean precise);
 548
 549
 550 static void init_stats (void);
 551
 552 static int mark_ephemerons_in_range (ScanCopyContext ctx);
 553 static void clear_unreachable_ephemerons (ScanCopyContext ctx);
 554 static void null_ephemerons_for_domain (MonoDomain *domain);
 555
 556 SgenMajorCollector major_collector;
 557 SgenMinorCollector sgen_minor_collector;
 558 /* FIXME: get rid of this */
 559 static GrayQueue gray_queue;
 560
 561 static SgenRememberedSet remset;
 562
 563 /* The gray queue to use from the main collection thread. */
 564 #define WORKERS_DISTRIBUTE_GRAY_QUEUE   (&gray_queue)
 565
 566 /*
 567  * The gray queue a worker job must use.  If we're not parallel or
 568  * concurrent, we use the main gray queue.
 569  */
 570 static SgenGrayQueue*
 571 sgen_workers_get_job_gray_queue (WorkerData *worker_data)
 572 {
 573         return worker_data ? &worker_data->private_gray_queue : WORKERS_DISTRIBUTE_GRAY_QUEUE;
 574 }
 575
 576 static void
 577 gray_queue_redirect (SgenGrayQueue *queue)
 578 {
 579         gboolean wake = FALSE;
 580
 581         for (;;) {
 582                 GrayQueueSection *section = sgen_gray_object_dequeue_section (queue);
 583                 if (!section)
 584                         break;
 585                 sgen_section_gray_queue_enqueue (queue->alloc_prepare_data, section);
 586                 wake = TRUE;
 587         }
 588
 589         if (wake) {
 590                 g_assert (concurrent_collection_in_progress);
 591                 sgen_workers_ensure_awake ();
 592         }
 593 }
 594
 595 static void
 596 gray_queue_enable_redirect (SgenGrayQueue *queue)
 597 {
 598         if (!concurrent_collection_in_progress)
 599                 return;
 600
 601         sgen_gray_queue_set_alloc_prepare (queue, gray_queue_redirect, sgen_workers_get_distribute_section_gray_queue ());
 602         gray_queue_redirect (queue);
 603 }
 604
 605 void
 606 sgen_scan_area_with_callback (char *start, char *end, IterateObjectCallbackFunc callback, void *data, gboolean allow_flags)
 607 {
 608         while (start < end) {
 609                 size_t size;
 610                 char *obj;
 611
 612                 if (!*(void**)start) {
 613                         start += sizeof (void*); /* should be ALLOC_ALIGN, really */
 614                         continue;
 615                 }
 616
 617                 if (allow_flags) {
 618                         if (!(obj = SGEN_OBJECT_IS_FORWARDED (start)))
 619                                 obj = start;
 620                 } else {
 621                         obj = start;
 622                 }
 623
 624                 if ((MonoVTable*)SGEN_LOAD_VTABLE (obj) != array_fill_vtable) {
 625                         CHECK_CANARY_FOR_OBJECT (obj);
 626                         size = ALIGN_UP (safe_object_get_size ((MonoObject*)obj));
 627                         callback (obj, size, data);
 628                         CANARIFY_SIZE (size);
 629                 } else {
 630                         size = ALIGN_UP (safe_object_get_size ((MonoObject*)obj));
 631                 }
 632
 633                 start += size;
 634         }
 635 }
 636
 637 static gboolean
 638 need_remove_object_for_domain (char *start, MonoDomain *domain)
 639 {
 640         if (mono_object_domain (start) == domain) {
 641                 SGEN_LOG (4, "Need to cleanup object %p", start);
 642                 binary_protocol_cleanup (start, (gpointer)LOAD_VTABLE (start), safe_object_get_size ((MonoObject*)start));
 643                 return TRUE;
 644         }
 645         return FALSE;
 646 }
 647
 648 static void
 649 process_object_for_domain_clearing (char *start, MonoDomain *domain)
 650 {
 651         GCVTable *vt = (GCVTable*)LOAD_VTABLE (start);
 652         if (vt->klass == mono_defaults.internal_thread_class)
 653                 g_assert (mono_object_domain (start) == mono_get_root_domain ());
 654         /* The object could be a proxy for an object in the domain
 655            we're deleting. */
 656 #ifndef DISABLE_REMOTING
 657         if (mono_defaults.real_proxy_class->supertypes && mono_class_has_parent_fast (vt->klass, mono_defaults.real_proxy_class)) {
 658                 MonoObject *server = ((MonoRealProxy*)start)->unwrapped_server;
 659
 660                 /* The server could already have been zeroed out, so
 661                    we need to check for that, too. */
 662                 if (server && (!LOAD_VTABLE (server) || mono_object_domain (server) == domain)) {
 663                         SGEN_LOG (4, "Cleaning up remote pointer in %p to object %p", start, server);
 664                         ((MonoRealProxy*)start)->unwrapped_server = NULL;
 665                 }
 666         }
 667 #endif
 668 }
 669
 670 static gboolean
 671 clear_domain_process_object (char *obj, MonoDomain *domain)
 672 {
 673         gboolean remove;
 674
 675         process_object_for_domain_clearing (obj, domain);
 676         remove = need_remove_object_for_domain (obj, domain);
 677
 678         if (remove && ((MonoObject*)obj)->synchronisation) {
 679                 void **dislink = mono_monitor_get_object_monitor_weak_link ((MonoObject*)obj);
 680                 if (dislink)
 681                         sgen_register_disappearing_link (NULL, dislink, FALSE, TRUE);
 682         }
 683
 684         return remove;
 685 }
 686
 687 static void
 688 clear_domain_process_minor_object_callback (char *obj, size_t size, MonoDomain *domain)
 689 {
 690         if (clear_domain_process_object (obj, domain)) {
 691                 CANARIFY_SIZE (size);
 692                 memset (obj, 0, size);
 693         }
 694 }
 695
 696 static void
 697 clear_domain_process_major_object_callback (char *obj, size_t size, MonoDomain *domain)
 698 {
 699         clear_domain_process_object (obj, domain);
 700 }
 701
 702 static void
 703 clear_domain_free_major_non_pinned_object_callback (char *obj, size_t size, MonoDomain *domain)
 704 {
 705         if (need_remove_object_for_domain (obj, domain))
 706                 major_collector.free_non_pinned_object (obj, size);
 707 }
 708
 709 static void
 710 clear_domain_free_major_pinned_object_callback (char *obj, size_t size, MonoDomain *domain)
 711 {
 712         if (need_remove_object_for_domain (obj, domain))
 713                 major_collector.free_pinned_object (obj, size);
 714 }
 715
 716 /*
 717  * When appdomains are unloaded we can easily remove objects that have finalizers,
 718  * but all the others could still be present in random places on the heap.
 719  * We need a sweep to get rid of them even though it's going to be costly
 720  * with big heaps.
 721  * The reason we need to remove them is because we access the vtable and class
 722  * structures to know the object size and the reference bitmap: once the domain is
 723  * unloaded the point to random memory.
 724  */
 725 void
 726 mono_gc_clear_domain (MonoDomain * domain)
 727 {
 728         LOSObject *bigobj, *prev;
 729         int i;
 730
 731         LOCK_GC;
 732
 733         binary_protocol_domain_unload_begin (domain);
 734
 735         sgen_stop_world (0);
 736
 737         if (concurrent_collection_in_progress)
 738                 sgen_perform_collection (0, GENERATION_OLD, "clear domain", TRUE);
 739         g_assert (!concurrent_collection_in_progress);
 740
 741         major_collector.finish_sweeping ();
 742
 743         sgen_process_fin_stage_entries ();
 744         sgen_process_dislink_stage_entries ();
 745
 746         sgen_clear_nursery_fragments ();
 747
 748         if (xdomain_checks && domain != mono_get_root_domain ()) {
 749                 sgen_scan_for_registered_roots_in_domain (domain, ROOT_TYPE_NORMAL);
 750                 sgen_scan_for_registered_roots_in_domain (domain, ROOT_TYPE_WBARRIER);
 751                 sgen_check_for_xdomain_refs ();
 752         }
 753
 754         /*Ephemerons and dislinks must be processed before LOS since they might end up pointing
 755         to memory returned to the OS.*/
 756         null_ephemerons_for_domain (domain);
 757
 758         for (i = GENERATION_NURSERY; i < GENERATION_MAX; ++i)
 759                 sgen_null_links_for_domain (domain, i);
 760
 761         for (i = GENERATION_NURSERY; i < GENERATION_MAX; ++i)
 762                 sgen_remove_finalizers_for_domain (domain, i);
 763
 764         sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data,
 765                         (IterateObjectCallbackFunc)clear_domain_process_minor_object_callback, domain, FALSE);
 766
 767         /* We need two passes over major and large objects because
 768            freeing such objects might give their memory back to the OS
 769            (in the case of large objects) or obliterate its vtable
 770            (pinned objects with major-copying or pinned and non-pinned
 771            objects with major-mark&sweep), but we might need to
 772            dereference a pointer from an object to another object if
 773            the first object is a proxy. */
 774         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, (IterateObjectCallbackFunc)clear_domain_process_major_object_callback, domain);
 775         for (bigobj = los_object_list; bigobj; bigobj = bigobj->next)
 776                 clear_domain_process_object (bigobj->data, domain);
 777
 778         prev = NULL;
 779         for (bigobj = los_object_list; bigobj;) {
 780                 if (need_remove_object_for_domain (bigobj->data, domain)) {
 781                         LOSObject *to_free = bigobj;
 782                         if (prev)
 783                                 prev->next = bigobj->next;
 784                         else
 785                                 los_object_list = bigobj->next;
 786                         bigobj = bigobj->next;
 787                         SGEN_LOG (4, "Freeing large object %p", bigobj->data);
 788                         sgen_los_free_object (to_free);
 789                         continue;
 790                 }
 791                 prev = bigobj;
 792                 bigobj = bigobj->next;
 793         }
 794         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_NON_PINNED, (IterateObjectCallbackFunc)clear_domain_free_major_non_pinned_object_callback, domain);
 795         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_PINNED, (IterateObjectCallbackFunc)clear_domain_free_major_pinned_object_callback, domain);
 796
 797         if (domain == mono_get_root_domain ()) {
 798                 sgen_pin_stats_print_class_stats ();
 799                 sgen_object_layout_dump (stdout);
 800         }
 801
 802         sgen_restart_world (0, NULL);
 803
 804         binary_protocol_domain_unload_end (domain);
 805         binary_protocol_flush_buffers (FALSE);
 806
 807         UNLOCK_GC;
 808 }
 809
 810 /*
 811  * sgen_add_to_global_remset:
 812  *
 813  *   The global remset contains locations which point into newspace after
 814  * a minor collection. This can happen if the objects they point to are pinned.
 815  *
 816  * LOCKING: If called from a parallel collector, the global remset
 817  * lock must be held.  For serial collectors that is not necessary.
 818  */
 819 void
 820 sgen_add_to_global_remset (gpointer ptr, gpointer obj)
 821 {
 822         SGEN_ASSERT (5, sgen_ptr_in_nursery (obj), "Target pointer of global remset must be in the nursery");
 823
 824         HEAVY_STAT (++stat_wbarrier_add_to_global_remset);
 825
 826         if (!major_collector.is_concurrent) {
 827                 SGEN_ASSERT (5, current_collection_generation != -1, "Global remsets can only be added during collections");
 828         } else {
 829                 if (current_collection_generation == -1)
 830                         SGEN_ASSERT (5, sgen_concurrent_collection_in_progress (), "Global remsets outside of collection pauses can only be added by the concurrent collector");
 831         }
 832
 833         if (!object_is_pinned (obj))
 834                 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");
 835         else if (sgen_cement_lookup_or_register (obj))
 836                 return;
 837
 838         remset.record_pointer (ptr);
 839
 840         sgen_pin_stats_register_global_remset (obj);
 841
 842         SGEN_LOG (8, "Adding global remset for %p", ptr);
 843         binary_protocol_global_remset (ptr, obj, (gpointer)SGEN_LOAD_VTABLE (obj));
 844
 845
 846 #ifdef ENABLE_DTRACE
 847         if (G_UNLIKELY (MONO_GC_GLOBAL_REMSET_ADD_ENABLED ())) {
 848                 MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (obj);
 849                 MONO_GC_GLOBAL_REMSET_ADD ((mword)ptr, (mword)obj, sgen_safe_object_get_size (obj),
 850                                 vt->klass->name_space, vt->klass->name);
 851         }
 852 #endif
 853 }
 854
 855 /*
 856  * sgen_drain_gray_stack:
 857  *
 858  *   Scan objects in the gray stack until the stack is empty. This should be called
 859  * frequently after each object is copied, to achieve better locality and cache
 860  * usage.
 861  *
 862  * max_objs is the maximum number of objects to scan, or -1 to scan until the stack is
 863  * empty.
 864  */
 865 gboolean
 866 sgen_drain_gray_stack (int max_objs, ScanCopyContext ctx)
 867 {
 868         ScanObjectFunc scan_func = ctx.ops->scan_object;
 869         GrayQueue *queue = ctx.queue;
 870
 871         if (current_collection_generation == GENERATION_OLD && major_collector.drain_gray_stack)
 872                 return major_collector.drain_gray_stack (ctx);
 873
 874         do {
 875                 int i;
 876                 for (i = 0; i != max_objs; ++i) {
 877                         char *obj;
 878                         mword desc;
 879                         GRAY_OBJECT_DEQUEUE (queue, &obj, &desc);
 880                         if (!obj)
 881                                 return TRUE;
 882                         SGEN_LOG (9, "Precise gray object scan %p (%s)", obj, safe_name (obj));
 883                         scan_func (obj, desc, queue);
 884                 }
 885         } while (max_objs < 0);
 886         return FALSE;
 887 }
 888
 889 /*
 890  * Addresses in the pin queue are already sorted. This function finds
 891  * the object header for each address and pins the object. The
 892  * addresses must be inside the nursery section.  The (start of the)
 893  * address array is overwritten with the addresses of the actually
 894  * pinned objects.  Return the number of pinned objects.
 895  */
 896 static int
 897 pin_objects_from_nursery_pin_queue (gboolean do_scan_objects, ScanCopyContext ctx)
 898 {
 899         GCMemSection *section = nursery_section;
 900         void **start =  sgen_pinning_get_entry (section->pin_queue_first_entry);
 901         void **end = sgen_pinning_get_entry (section->pin_queue_last_entry);
 902         void *start_nursery = section->data;
 903         void *end_nursery = section->next_data;
 904         void *last = NULL;
 905         int count = 0;
 906         void *search_start;
 907         void *addr;
 908         void *pinning_front = start_nursery;
 909         size_t idx;
 910         void **definitely_pinned = start;
 911         ScanObjectFunc scan_func = ctx.ops->scan_object;
 912         SgenGrayQueue *queue = ctx.queue;
 913
 914         sgen_nursery_allocator_prepare_for_pinning ();
 915
 916         while (start < end) {
 917                 void *obj_to_pin = NULL;
 918                 size_t obj_to_pin_size = 0;
 919                 mword desc;
 920
 921                 addr = *start;
 922
 923                 SGEN_ASSERT (0, addr >= start_nursery && addr < end_nursery, "Potential pinning address out of range");
 924                 SGEN_ASSERT (0, addr >= last, "Pin queue not sorted");
 925
 926                 if (addr == last) {
 927                         ++start;
 928                         continue;
 929                 }
 930
 931                 SGEN_LOG (5, "Considering pinning addr %p", addr);
 932                 /* We've already processed everything up to pinning_front. */
 933                 if (addr < pinning_front) {
 934                         start++;
 935                         continue;
 936                 }
 937
 938                 /*
 939                  * Find the closest scan start <= addr.  We might search backward in the
 940                  * scan_starts array because entries might be NULL.  In the worst case we
 941                  * start at start_nursery.
 942                  */
 943                 idx = ((char*)addr - (char*)section->data) / SCAN_START_SIZE;
 944                 SGEN_ASSERT (0, idx < section->num_scan_start, "Scan start index out of range");
 945                 search_start = (void*)section->scan_starts [idx];
 946                 if (!search_start || search_start > addr) {
 947                         while (idx) {
 948                                 --idx;
 949                                 search_start = section->scan_starts [idx];
 950                                 if (search_start && search_start <= addr)
 951                                         break;
 952                         }
 953                         if (!search_start || search_start > addr)
 954                                 search_start = start_nursery;
 955                 }
 956
 957                 /*
 958                  * If the pinning front is closer than the scan start we found, start
 959                  * searching at the front.
 960                  */
 961                 if (search_start < pinning_front)
 962                         search_start = pinning_front;
 963
 964                 /*
 965                  * Now addr should be in an object a short distance from search_start.
 966                  *
 967                  * search_start must point to zeroed mem or point to an object.
 968                  */
 969                 do {
 970                         size_t obj_size, canarified_obj_size;
 971
 972                         /* Skip zeros. */
 973                         if (!*(void**)search_start) {
 974                                 search_start = (void*)ALIGN_UP ((mword)search_start + sizeof (gpointer));
 975                                 /* The loop condition makes sure we don't overrun addr. */
 976                                 continue;
 977                         }
 978
 979                         canarified_obj_size = obj_size = ALIGN_UP (safe_object_get_size ((MonoObject*)search_start));
 980
 981                         /*
 982                          * Filler arrays are marked by an invalid sync word.  We don't
 983                          * consider them for pinning.  They are not delimited by canaries,
 984                          * either.
 985                          */
 986                         if (((MonoObject*)search_start)->synchronisation != GINT_TO_POINTER (-1)) {
 987                                 CHECK_CANARY_FOR_OBJECT (search_start);
 988                                 CANARIFY_SIZE (canarified_obj_size);
 989
 990                                 if (addr >= search_start && (char*)addr < (char*)search_start + obj_size) {
 991                                         /* This is the object we're looking for. */
 992                                         obj_to_pin = search_start;
 993                                         obj_to_pin_size = canarified_obj_size;
 994                                         break;
 995                                 }
 996                         }
 997
 998                         /* Skip to the next object */
 999                         search_start = (void*)((char*)search_start + canarified_obj_size);
1000                 } while (search_start <= addr);
1001
1002                 /* We've searched past the address we were looking for. */
1003                 if (!obj_to_pin) {
1004                         pinning_front = search_start;
1005                         goto next_pin_queue_entry;
1006                 }
1007
1008                 /*
1009                  * We've found an object to pin.  It might still be a dummy array, but we
1010                  * can advance the pinning front in any case.
1011                  */
1012                 pinning_front = (char*)obj_to_pin + obj_to_pin_size;
1013
1014                 /*
1015                  * If this is a dummy array marking the beginning of a nursery
1016                  * fragment, we don't pin it.
1017                  */
1018                 if (((MonoObject*)obj_to_pin)->synchronisation == GINT_TO_POINTER (-1))
1019                         goto next_pin_queue_entry;
1020
1021                 /*
1022                  * Finally - pin the object!
1023                  */
1024                 desc = sgen_obj_get_descriptor_safe (obj_to_pin);
1025                 if (do_scan_objects) {
1026                         scan_func (obj_to_pin, desc, queue);
1027                 } else {
1028                         SGEN_LOG (4, "Pinned object %p, vtable %p (%s), count %d\n",
1029                                         obj_to_pin, *(void**)obj_to_pin, safe_name (obj_to_pin), count);
1030                         binary_protocol_pin (obj_to_pin,
1031                                         (gpointer)LOAD_VTABLE (obj_to_pin),
1032                                         safe_object_get_size (obj_to_pin));
1033
1034 #ifdef ENABLE_DTRACE
1035                         if (G_UNLIKELY (MONO_GC_OBJ_PINNED_ENABLED ())) {
1036                                 int gen = sgen_ptr_in_nursery (obj_to_pin) ? GENERATION_NURSERY : GENERATION_OLD;
1037                                 MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (obj_to_pin);
1038                                 MONO_GC_OBJ_PINNED ((mword)obj_to_pin,
1039                                                 sgen_safe_object_get_size (obj_to_pin),
1040                                                 vt->klass->name_space, vt->klass->name, gen);
1041                         }
1042 #endif
1043
1044                         pin_object (obj_to_pin);
1045                         GRAY_OBJECT_ENQUEUE (queue, obj_to_pin, desc);
1046                         sgen_pin_stats_register_object (obj_to_pin, obj_to_pin_size);
1047                         definitely_pinned [count] = obj_to_pin;
1048                         count++;
1049                 }
1050
1051         next_pin_queue_entry:
1052                 last = addr;
1053                 ++start;
1054         }
1055         //printf ("effective pinned: %d (at the end: %d)\n", count, (char*)end_nursery - (char*)last);
1056         if (mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS) {
1057                 GCRootReport report;
1058                 report.count = 0;
1059                 for (idx = 0; idx < count; ++idx)
1060                         add_profile_gc_root (&report, definitely_pinned [idx], MONO_PROFILE_GC_ROOT_PINNING | MONO_PROFILE_GC_ROOT_MISC, 0);
1061                 notify_gc_roots (&report);
1062         }
1063         stat_pinned_objects += count;
1064         return count;
1065 }
1066
1067 static void
1068 pin_objects_in_nursery (gboolean do_scan_objects, ScanCopyContext ctx)
1069 {
1070         size_t reduced_to;
1071
1072         if (nursery_section->pin_queue_first_entry == nursery_section->pin_queue_last_entry)
1073                 return;
1074
1075         reduced_to = pin_objects_from_nursery_pin_queue (do_scan_objects, ctx);
1076         nursery_section->pin_queue_last_entry = nursery_section->pin_queue_first_entry + reduced_to;
1077 }
1078
1079 /*
1080  * This function is only ever called (via `collector_pin_object()` in `sgen-copy-object.h`)
1081  * when we can't promote an object because we're out of memory.
1082  */
1083 void
1084 sgen_pin_object (void *object, GrayQueue *queue)
1085 {
1086         /*
1087          * All pinned objects are assumed to have been staged, so we need to stage as well.
1088          * Also, the count of staged objects shows that "late pinning" happened.
1089          */
1090         sgen_pin_stage_ptr (object);
1091
1092         SGEN_PIN_OBJECT (object);
1093         binary_protocol_pin (object, (gpointer)LOAD_VTABLE (object), safe_object_get_size (object));
1094
1095         ++objects_pinned;
1096         sgen_pin_stats_register_object (object, safe_object_get_size (object));
1097
1098         GRAY_OBJECT_ENQUEUE (queue, object, sgen_obj_get_descriptor_safe (object));
1099
1100 #ifdef ENABLE_DTRACE
1101         if (G_UNLIKELY (MONO_GC_OBJ_PINNED_ENABLED ())) {
1102                 int gen = sgen_ptr_in_nursery (object) ? GENERATION_NURSERY : GENERATION_OLD;
1103                 MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (object);
1104                 MONO_GC_OBJ_PINNED ((mword)object, sgen_safe_object_get_size (object), vt->klass->name_space, vt->klass->name, gen);
1105         }
1106 #endif
1107 }
1108
1109 /* Sort the addresses in array in increasing order.
1110  * Done using a by-the book heap sort. Which has decent and stable performance, is pretty cache efficient.
1111  */
1112 void
1113 sgen_sort_addresses (void **array, size_t size)
1114 {
1115         size_t i;
1116         void *tmp;
1117
1118         for (i = 1; i < size; ++i) {
1119                 size_t child = i;
1120                 while (child > 0) {
1121                         size_t parent = (child - 1) / 2;
1122
1123                         if (array [parent] >= array [child])
1124                                 break;
1125
1126                         tmp = array [parent];
1127                         array [parent] = array [child];
1128                         array [child] = tmp;
1129
1130                         child = parent;
1131                 }
1132         }
1133
1134         for (i = size - 1; i > 0; --i) {
1135                 size_t end, root;
1136                 tmp = array [i];
1137                 array [i] = array [0];
1138                 array [0] = tmp;
1139
1140                 end = i - 1;
1141                 root = 0;
1142
1143                 while (root * 2 + 1 <= end) {
1144                         size_t child = root * 2 + 1;
1145
1146                         if (child < end && array [child] < array [child + 1])
1147                                 ++child;
1148                         if (array [root] >= array [child])
1149                                 break;
1150
1151                         tmp = array [root];
1152                         array [root] = array [child];
1153                         array [child] = tmp;
1154
1155                         root = child;
1156                 }
1157         }
1158 }
1159
1160 /*
1161  * Scan the memory between start and end and queue values which could be pointers
1162  * to the area between start_nursery and end_nursery for later consideration.
1163  * Typically used for thread stacks.
1164  */
1165 static void
1166 conservatively_pin_objects_from (void **start, void **end, void *start_nursery, void *end_nursery, int pin_type)
1167 {
1168         int count = 0;
1169
1170 #ifdef VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE
1171         VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE (start, (char*)end - (char*)start);
1172 #endif
1173
1174         while (start < end) {
1175                 if (*start >= start_nursery && *start < end_nursery) {
1176                         /*
1177                          * *start can point to the middle of an object
1178                          * note: should we handle pointing at the end of an object?
1179                          * pinning in C# code disallows pointing at the end of an object
1180                          * but there is some small chance that an optimizing C compiler
1181                          * may keep the only reference to an object by pointing
1182                          * at the end of it. We ignore this small chance for now.
1183                          * Pointers to the end of an object are indistinguishable
1184                          * from pointers to the start of the next object in memory
1185                          * so if we allow that we'd need to pin two objects...
1186                          * We queue the pointer in an array, the
1187                          * array will then be sorted and uniqued. This way
1188                          * we can coalesce several pinning pointers and it should
1189                          * be faster since we'd do a memory scan with increasing
1190                          * addresses. Note: we can align the address to the allocation
1191                          * alignment, so the unique process is more effective.
1192                          */
1193                         mword addr = (mword)*start;
1194                         addr &= ~(ALLOC_ALIGN - 1);
1195                         if (addr >= (mword)start_nursery && addr < (mword)end_nursery) {
1196                                 SGEN_LOG (6, "Pinning address %p from %p", (void*)addr, start);
1197                                 sgen_pin_stage_ptr ((void*)addr);
1198                                 binary_protocol_pin_stage (start, (void*)addr);
1199                                 count++;
1200                         }
1201                         if (ptr_in_nursery ((void*)addr))
1202                                 sgen_pin_stats_register_address ((char*)addr, pin_type);
1203                 }
1204                 start++;
1205         }
1206         if (count)
1207                 SGEN_LOG (7, "found %d potential pinned heap pointers", count);
1208 }
1209
1210 /*
1211  * The first thing we do in a collection is to identify pinned objects.
1212  * This function considers all the areas of memory that need to be
1213  * conservatively scanned.
1214  */
1215 static void
1216 pin_from_roots (void *start_nursery, void *end_nursery, ScanCopyContext ctx)
1217 {
1218         void **start_root;
1219         RootRecord *root;
1220         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);
1221         /* objects pinned from the API are inside these roots */
1222         SGEN_HASH_TABLE_FOREACH (&roots_hash [ROOT_TYPE_PINNED], start_root, root) {
1223                 SGEN_LOG (6, "Pinned roots %p-%p", start_root, root->end_root);
1224                 conservatively_pin_objects_from (start_root, (void**)root->end_root, start_nursery, end_nursery, PIN_TYPE_OTHER);
1225         } SGEN_HASH_TABLE_FOREACH_END;
1226         /* now deal with the thread stacks
1227          * in the future we should be able to conservatively scan only:
1228          * *) the cpu registers
1229          * *) the unmanaged stack frames
1230          * *) the _last_ managed stack frame
1231          * *) pointers slots in managed frames
1232          */
1233         scan_thread_data (start_nursery, end_nursery, FALSE, ctx);
1234 }
1235
1236 static void
1237 unpin_objects_from_queue (SgenGrayQueue *queue)
1238 {
1239         for (;;) {
1240                 char *addr;
1241                 mword desc;
1242                 GRAY_OBJECT_DEQUEUE (queue, &addr, &desc);
1243                 if (!addr)
1244                         break;
1245                 g_assert (SGEN_OBJECT_IS_PINNED (addr));
1246                 SGEN_UNPIN_OBJECT (addr);
1247         }
1248 }
1249
1250 static void
1251 single_arg_user_copy_or_mark (void **obj, void *gc_data)
1252 {
1253         ScanCopyContext *ctx = gc_data;
1254         ctx->ops->copy_or_mark_object (obj, ctx->queue);
1255 }
1256
1257 /*
1258  * The memory area from start_root to end_root contains pointers to objects.
1259  * Their position is precisely described by @desc (this means that the pointer
1260  * can be either NULL or the pointer to the start of an object).
1261  * This functions copies them to to_space updates them.
1262  *
1263  * This function is not thread-safe!
1264  */
1265 static void
1266 precisely_scan_objects_from (void** start_root, void** end_root, char* n_start, char *n_end, mword desc, ScanCopyContext ctx)
1267 {
1268         CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object;
1269         SgenGrayQueue *queue = ctx.queue;
1270
1271         switch (desc & ROOT_DESC_TYPE_MASK) {
1272         case ROOT_DESC_BITMAP:
1273                 desc >>= ROOT_DESC_TYPE_SHIFT;
1274                 while (desc) {
1275                         if ((desc & 1) && *start_root) {
1276                                 copy_func (start_root, queue);
1277                                 SGEN_LOG (9, "Overwrote root at %p with %p", start_root, *start_root);
1278                         }
1279                         desc >>= 1;
1280                         start_root++;
1281                 }
1282                 return;
1283         case ROOT_DESC_COMPLEX: {
1284                 gsize *bitmap_data = sgen_get_complex_descriptor_bitmap (desc);
1285                 gsize bwords = (*bitmap_data) - 1;
1286                 void **start_run = start_root;
1287                 bitmap_data++;
1288                 while (bwords-- > 0) {
1289                         gsize bmap = *bitmap_data++;
1290                         void **objptr = start_run;
1291                         while (bmap) {
1292                                 if ((bmap & 1) && *objptr) {
1293                                         copy_func (objptr, queue);
1294                                         SGEN_LOG (9, "Overwrote root at %p with %p", objptr, *objptr);
1295                                 }
1296                                 bmap >>= 1;
1297                                 ++objptr;
1298                         }
1299                         start_run += GC_BITS_PER_WORD;
1300                 }
1301                 break;
1302         }
1303         case ROOT_DESC_USER: {
1304                 MonoGCRootMarkFunc marker = sgen_get_user_descriptor_func (desc);
1305                 marker (start_root, single_arg_user_copy_or_mark, &ctx);
1306                 break;
1307         }
1308         case ROOT_DESC_RUN_LEN:
1309                 g_assert_not_reached ();
1310         default:
1311                 g_assert_not_reached ();
1312         }
1313 }
1314
1315 static void
1316 reset_heap_boundaries (void)
1317 {
1318         lowest_heap_address = ~(mword)0;
1319         highest_heap_address = 0;
1320 }
1321
1322 void
1323 sgen_update_heap_boundaries (mword low, mword high)
1324 {
1325         mword old;
1326
1327         do {
1328                 old = lowest_heap_address;
1329                 if (low >= old)
1330                         break;
1331         } while (SGEN_CAS_PTR ((gpointer*)&lowest_heap_address, (gpointer)low, (gpointer)old) != (gpointer)old);
1332
1333         do {
1334                 old = highest_heap_address;
1335                 if (high <= old)
1336                         break;
1337         } while (SGEN_CAS_PTR ((gpointer*)&highest_heap_address, (gpointer)high, (gpointer)old) != (gpointer)old);
1338 }
1339
1340 /*
1341  * Allocate and setup the data structures needed to be able to allocate objects
1342  * in the nursery. The nursery is stored in nursery_section.
1343  */
1344 static void
1345 alloc_nursery (void)
1346 {
1347         GCMemSection *section;
1348         char *data;
1349         size_t scan_starts;
1350         size_t alloc_size;
1351
1352         if (nursery_section)
1353                 return;
1354         SGEN_LOG (2, "Allocating nursery size: %zu", (size_t)sgen_nursery_size);
1355         /* later we will alloc a larger area for the nursery but only activate
1356          * what we need. The rest will be used as expansion if we have too many pinned
1357          * objects in the existing nursery.
1358          */
1359         /* FIXME: handle OOM */
1360         section = sgen_alloc_internal (INTERNAL_MEM_SECTION);
1361
1362         alloc_size = sgen_nursery_size;
1363
1364         /* If there isn't enough space even for the nursery we should simply abort. */
1365         g_assert (sgen_memgov_try_alloc_space (alloc_size, SPACE_NURSERY));
1366
1367         data = major_collector.alloc_heap (alloc_size, alloc_size, DEFAULT_NURSERY_BITS);
1368         sgen_update_heap_boundaries ((mword)data, (mword)(data + sgen_nursery_size));
1369         SGEN_LOG (4, "Expanding nursery size (%p-%p): %lu, total: %lu", data, data + alloc_size, (unsigned long)sgen_nursery_size, (unsigned long)mono_gc_get_heap_size ());
1370         section->data = section->next_data = data;
1371         section->size = alloc_size;
1372         section->end_data = data + sgen_nursery_size;
1373         scan_starts = (alloc_size + SCAN_START_SIZE - 1) / SCAN_START_SIZE;
1374         section->scan_starts = sgen_alloc_internal_dynamic (sizeof (char*) * scan_starts, INTERNAL_MEM_SCAN_STARTS, TRUE);
1375         section->num_scan_start = scan_starts;
1376
1377         nursery_section = section;
1378
1379         sgen_nursery_allocator_set_nursery_bounds (data, data + sgen_nursery_size);
1380 }
1381
1382 void*
1383 mono_gc_get_nursery (int *shift_bits, size_t *size)
1384 {
1385         *size = sgen_nursery_size;
1386         *shift_bits = DEFAULT_NURSERY_BITS;
1387         return sgen_get_nursery_start ();
1388 }
1389
1390 void
1391 mono_gc_set_current_thread_appdomain (MonoDomain *domain)
1392 {
1393         SgenThreadInfo *info = mono_thread_info_current ();
1394
1395         /* Could be called from sgen_thread_unregister () with a NULL info */
1396         if (domain) {
1397                 g_assert (info);
1398                 info->stopped_domain = domain;
1399         }
1400 }
1401
1402 gboolean
1403 mono_gc_precise_stack_mark_enabled (void)
1404 {
1405         return !conservative_stack_mark;
1406 }
1407
1408 FILE *
1409 mono_gc_get_logfile (void)
1410 {
1411         return gc_debug_file;
1412 }
1413
1414 static void
1415 report_finalizer_roots_list (FinalizeReadyEntry *list)
1416 {
1417         GCRootReport report;
1418         FinalizeReadyEntry *fin;
1419
1420         report.count = 0;
1421         for (fin = list; fin; fin = fin->next) {
1422                 if (!fin->object)
1423                         continue;
1424                 add_profile_gc_root (&report, fin->object, MONO_PROFILE_GC_ROOT_FINALIZER, 0);
1425         }
1426         notify_gc_roots (&report);
1427 }
1428
1429 static void
1430 report_finalizer_roots (void)
1431 {
1432         report_finalizer_roots_list (fin_ready_list);
1433         report_finalizer_roots_list (critical_fin_list);
1434 }
1435
1436 static GCRootReport *root_report;
1437
1438 static void
1439 single_arg_report_root (void **obj, void *gc_data)
1440 {
1441         if (*obj)
1442                 add_profile_gc_root (root_report, *obj, MONO_PROFILE_GC_ROOT_OTHER, 0);
1443 }
1444
1445 static void
1446 precisely_report_roots_from (GCRootReport *report, void** start_root, void** end_root, mword desc)
1447 {
1448         switch (desc & ROOT_DESC_TYPE_MASK) {
1449         case ROOT_DESC_BITMAP:
1450                 desc >>= ROOT_DESC_TYPE_SHIFT;
1451                 while (desc) {
1452                         if ((desc & 1) && *start_root) {
1453                                 add_profile_gc_root (report, *start_root, MONO_PROFILE_GC_ROOT_OTHER, 0);
1454                         }
1455                         desc >>= 1;
1456                         start_root++;
1457                 }
1458                 return;
1459         case ROOT_DESC_COMPLEX: {
1460                 gsize *bitmap_data = sgen_get_complex_descriptor_bitmap (desc);
1461                 gsize bwords = (*bitmap_data) - 1;
1462                 void **start_run = start_root;
1463                 bitmap_data++;
1464                 while (bwords-- > 0) {
1465                         gsize bmap = *bitmap_data++;
1466                         void **objptr = start_run;
1467                         while (bmap) {
1468                                 if ((bmap & 1) && *objptr) {
1469                                         add_profile_gc_root (report, *objptr, MONO_PROFILE_GC_ROOT_OTHER, 0);
1470                                 }
1471                                 bmap >>= 1;
1472                                 ++objptr;
1473                         }
1474                         start_run += GC_BITS_PER_WORD;
1475                 }
1476                 break;
1477         }
1478         case ROOT_DESC_USER: {
1479                 MonoGCRootMarkFunc marker = sgen_get_user_descriptor_func (desc);
1480                 root_report = report;
1481                 marker (start_root, single_arg_report_root, NULL);
1482                 break;
1483         }
1484         case ROOT_DESC_RUN_LEN:
1485                 g_assert_not_reached ();
1486         default:
1487                 g_assert_not_reached ();
1488         }
1489 }
1490
1491 static void
1492 report_registered_roots_by_type (int root_type)
1493 {
1494         GCRootReport report;
1495         void **start_root;
1496         RootRecord *root;
1497         report.count = 0;
1498         SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], start_root, root) {
1499                 SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
1500                 precisely_report_roots_from (&report, start_root, (void**)root->end_root, root->root_desc);
1501         } SGEN_HASH_TABLE_FOREACH_END;
1502         notify_gc_roots (&report);
1503 }
1504
1505 static void
1506 report_registered_roots (void)
1507 {
1508         report_registered_roots_by_type (ROOT_TYPE_NORMAL);
1509         report_registered_roots_by_type (ROOT_TYPE_WBARRIER);
1510 }
1511
1512 static void
1513 scan_finalizer_entries (FinalizeReadyEntry *list, ScanCopyContext ctx)
1514 {
1515         CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object;
1516         SgenGrayQueue *queue = ctx.queue;
1517         FinalizeReadyEntry *fin;
1518
1519         for (fin = list; fin; fin = fin->next) {
1520                 if (!fin->object)
1521                         continue;
1522                 SGEN_LOG (5, "Scan of fin ready object: %p (%s)\n", fin->object, safe_name (fin->object));
1523                 copy_func (&fin->object, queue);
1524         }
1525 }
1526
1527 static const char*
1528 generation_name (int generation)
1529 {
1530         switch (generation) {
1531         case GENERATION_NURSERY: return "nursery";
1532         case GENERATION_OLD: return "old";
1533         default: g_assert_not_reached ();
1534         }
1535 }
1536
1537 const char*
1538 sgen_generation_name (int generation)
1539 {
1540         return generation_name (generation);
1541 }
1542
1543 static void
1544 finish_gray_stack (int generation, ScanCopyContext ctx)
1545 {
1546         TV_DECLARE (atv);
1547         TV_DECLARE (btv);
1548         int done_with_ephemerons, ephemeron_rounds = 0;
1549         char *start_addr = generation == GENERATION_NURSERY ? sgen_get_nursery_start () : NULL;
1550         char *end_addr = generation == GENERATION_NURSERY ? sgen_get_nursery_end () : (char*)-1;
1551         SgenGrayQueue *queue = ctx.queue;
1552
1553         /*
1554          * We copied all the reachable objects. Now it's the time to copy
1555          * the objects that were not referenced by the roots, but by the copied objects.
1556          * we built a stack of objects pointed to by gray_start: they are
1557          * additional roots and we may add more items as we go.
1558          * We loop until gray_start == gray_objects which means no more objects have
1559          * been added. Note this is iterative: no recursion is involved.
1560          * We need to walk the LO list as well in search of marked big objects
1561          * (use a flag since this is needed only on major collections). We need to loop
1562          * here as well, so keep a counter of marked LO (increasing it in copy_object).
1563          *   To achieve better cache locality and cache usage, we drain the gray stack
1564          * frequently, after each object is copied, and just finish the work here.
1565          */
1566         sgen_drain_gray_stack (-1, ctx);
1567         TV_GETTIME (atv);
1568         SGEN_LOG (2, "%s generation done", generation_name (generation));
1569
1570         /*
1571         Reset bridge data, we might have lingering data from a previous collection if this is a major
1572         collection trigged by minor overflow.
1573
1574         We must reset the gathered bridges since their original block might be evacuated due to major
1575         fragmentation in the meanwhile and the bridge code should not have to deal with that.
1576         */
1577         if (sgen_need_bridge_processing ())
1578                 sgen_bridge_reset_data ();
1579
1580         /*
1581          * Walk the ephemeron tables marking all values with reachable keys. This must be completely done
1582          * before processing finalizable objects and non-tracking weak links to avoid finalizing/clearing
1583          * objects that are in fact reachable.
1584          */
1585         done_with_ephemerons = 0;
1586         do {
1587                 done_with_ephemerons = mark_ephemerons_in_range (ctx);
1588                 sgen_drain_gray_stack (-1, ctx);
1589                 ++ephemeron_rounds;
1590         } while (!done_with_ephemerons);
1591
1592         sgen_mark_togglerefs (start_addr, end_addr, ctx);
1593
1594         if (sgen_need_bridge_processing ()) {
1595                 /*Make sure the gray stack is empty before we process bridge objects so we get liveness right*/
1596                 sgen_drain_gray_stack (-1, ctx);
1597                 sgen_collect_bridge_objects (generation, ctx);
1598                 if (generation == GENERATION_OLD)
1599                         sgen_collect_bridge_objects (GENERATION_NURSERY, ctx);
1600
1601                 /*
1602                 Do the first bridge step here, as the collector liveness state will become useless after that.
1603
1604                 An important optimization is to only proccess the possibly dead part of the object graph and skip
1605                 over all live objects as we transitively know everything they point must be alive too.
1606
1607                 The above invariant is completely wrong if we let the gray queue be drained and mark/copy everything.
1608
1609                 This has the unfortunate side effect of making overflow collections perform the first step twice, but
1610                 given we now have heuristics that perform major GC in anticipation of minor overflows this should not
1611                 be a big deal.
1612                 */
1613                 sgen_bridge_processing_stw_step ();
1614         }
1615
1616         /*
1617         Make sure we drain the gray stack before processing disappearing links and finalizers.
1618         If we don't make sure it is empty we might wrongly see a live object as dead.
1619         */
1620         sgen_drain_gray_stack (-1, ctx);
1621
1622         /*
1623         We must clear weak links that don't track resurrection before processing object ready for
1624         finalization so they can be cleared before that.
1625         */
1626         sgen_null_link_in_range (generation, TRUE, ctx);
1627         if (generation == GENERATION_OLD)
1628                 sgen_null_link_in_range (GENERATION_NURSERY, TRUE, ctx);
1629
1630
1631         /* walk the finalization queue and move also the objects that need to be
1632          * finalized: use the finalized objects as new roots so the objects they depend
1633          * on are also not reclaimed. As with the roots above, only objects in the nursery
1634          * are marked/copied.
1635          */
1636         sgen_finalize_in_range (generation, ctx);
1637         if (generation == GENERATION_OLD)
1638                 sgen_finalize_in_range (GENERATION_NURSERY, ctx);
1639         /* drain the new stack that might have been created */
1640         SGEN_LOG (6, "Precise scan of gray area post fin");
1641         sgen_drain_gray_stack (-1, ctx);
1642
1643         /*
1644          * This must be done again after processing finalizable objects since CWL slots are cleared only after the key is finalized.
1645          */
1646         done_with_ephemerons = 0;
1647         do {
1648                 done_with_ephemerons = mark_ephemerons_in_range (ctx);
1649                 sgen_drain_gray_stack (-1, ctx);
1650                 ++ephemeron_rounds;
1651         } while (!done_with_ephemerons);
1652
1653         /*
1654          * Clear ephemeron pairs with unreachable keys.
1655          * We pass the copy func so we can figure out if an array was promoted or not.
1656          */
1657         clear_unreachable_ephemerons (ctx);
1658
1659         /*
1660          * We clear togglerefs only after all possible chances of revival are done.
1661          * This is semantically more inline with what users expect and it allows for
1662          * user finalizers to correctly interact with TR objects.
1663         */
1664         sgen_clear_togglerefs (start_addr, end_addr, ctx);
1665
1666         TV_GETTIME (btv);
1667         SGEN_LOG (2, "Finalize queue handling scan for %s generation: %d usecs %d ephemeron rounds", generation_name (generation), TV_ELAPSED (atv, btv), ephemeron_rounds);
1668
1669         /*
1670          * handle disappearing links
1671          * Note we do this after checking the finalization queue because if an object
1672          * survives (at least long enough to be finalized) we don't clear the link.
1673          * This also deals with a possible issue with the monitor reclamation: with the Boehm
1674          * GC a finalized object my lose the monitor because it is cleared before the finalizer is
1675          * called.
1676          */
1677         g_assert (sgen_gray_object_queue_is_empty (queue));
1678         for (;;) {
1679                 sgen_null_link_in_range (generation, FALSE, ctx);
1680                 if (generation == GENERATION_OLD)
1681                         sgen_null_link_in_range (GENERATION_NURSERY, FALSE, ctx);
1682                 if (sgen_gray_object_queue_is_empty (queue))
1683                         break;
1684                 sgen_drain_gray_stack (-1, ctx);
1685         }
1686
1687         g_assert (sgen_gray_object_queue_is_empty (queue));
1688
1689         sgen_gray_object_queue_trim_free_list (queue);
1690 }
1691
1692 void
1693 sgen_check_section_scan_starts (GCMemSection *section)
1694 {
1695         size_t i;
1696         for (i = 0; i < section->num_scan_start; ++i) {
1697                 if (section->scan_starts [i]) {
1698                         mword size = safe_object_get_size ((MonoObject*) section->scan_starts [i]);
1699                         g_assert (size >= sizeof (MonoObject) && size <= MAX_SMALL_OBJ_SIZE);
1700                 }
1701         }
1702 }
1703
1704 static void
1705 check_scan_starts (void)
1706 {
1707         if (!do_scan_starts_check)
1708                 return;
1709         sgen_check_section_scan_starts (nursery_section);
1710         major_collector.check_scan_starts ();
1711 }
1712
1713 static void
1714 scan_from_registered_roots (char *addr_start, char *addr_end, int root_type, ScanCopyContext ctx)
1715 {
1716         void **start_root;
1717         RootRecord *root;
1718         SGEN_HASH_TABLE_FOREACH (&roots_hash [root_type], start_root, root) {
1719                 SGEN_LOG (6, "Precise root scan %p-%p (desc: %p)", start_root, root->end_root, (void*)root->root_desc);
1720                 precisely_scan_objects_from (start_root, (void**)root->end_root, addr_start, addr_end, root->root_desc, ctx);
1721         } SGEN_HASH_TABLE_FOREACH_END;
1722 }
1723
1724 void
1725 sgen_dump_occupied (char *start, char *end, char *section_start)
1726 {
1727         fprintf (heap_dump_file, "<occupied offset=\"%td\" size=\"%td\"/>\n", start - section_start, end - start);
1728 }
1729
1730 void
1731 sgen_dump_section (GCMemSection *section, const char *type)
1732 {
1733         char *start = section->data;
1734         char *end = section->data + section->size;
1735         char *occ_start = NULL;
1736         GCVTable *vt;
1737         char *old_start G_GNUC_UNUSED = NULL; /* just for debugging */
1738
1739         fprintf (heap_dump_file, "<section type=\"%s\" size=\"%lu\">\n", type, (unsigned long)section->size);
1740
1741         while (start < end) {
1742                 guint size;
1743                 MonoClass *class G_GNUC_UNUSED;
1744
1745                 if (!*(void**)start) {
1746                         if (occ_start) {
1747                                 sgen_dump_occupied (occ_start, start, section->data);
1748                                 occ_start = NULL;
1749                         }
1750                         start += sizeof (void*); /* should be ALLOC_ALIGN, really */
1751                         continue;
1752                 }
1753                 g_assert (start < section->next_data);
1754
1755                 if (!occ_start)
1756                         occ_start = start;
1757
1758                 vt = (GCVTable*)LOAD_VTABLE (start);
1759                 class = vt->klass;
1760
1761                 size = ALIGN_UP (safe_object_get_size ((MonoObject*) start));
1762
1763                 /*
1764                 fprintf (heap_dump_file, "<object offset=\"%d\" class=\"%s.%s\" size=\"%d\"/>\n",
1765                                 start - section->data,
1766                                 vt->klass->name_space, vt->klass->name,
1767                                 size);
1768                 */
1769
1770                 old_start = start;
1771                 start += size;
1772         }
1773         if (occ_start)
1774                 sgen_dump_occupied (occ_start, start, section->data);
1775
1776         fprintf (heap_dump_file, "</section>\n");
1777 }
1778
1779 static void
1780 dump_object (MonoObject *obj, gboolean dump_location)
1781 {
1782         static char class_name [1024];
1783
1784         MonoClass *class = mono_object_class (obj);
1785         int i, j;
1786
1787         /*
1788          * Python's XML parser is too stupid to parse angle brackets
1789          * in strings, so we just ignore them;
1790          */
1791         i = j = 0;
1792         while (class->name [i] && j < sizeof (class_name) - 1) {
1793                 if (!strchr ("<>\"", class->name [i]))
1794                         class_name [j++] = class->name [i];
1795                 ++i;
1796         }
1797         g_assert (j < sizeof (class_name));
1798         class_name [j] = 0;
1799
1800         fprintf (heap_dump_file, "<object class=\"%s.%s\" size=\"%zd\"",
1801                         class->name_space, class_name,
1802                         safe_object_get_size (obj));
1803         if (dump_location) {
1804                 const char *location;
1805                 if (ptr_in_nursery (obj))
1806                         location = "nursery";
1807                 else if (safe_object_get_size (obj) <= MAX_SMALL_OBJ_SIZE)
1808                         location = "major";
1809                 else
1810                         location = "LOS";
1811                 fprintf (heap_dump_file, " location=\"%s\"", location);
1812         }
1813         fprintf (heap_dump_file, "/>\n");
1814 }
1815
1816 static void
1817 dump_heap (const char *type, int num, const char *reason)
1818 {
1819         ObjectList *list;
1820         LOSObject *bigobj;
1821
1822         fprintf (heap_dump_file, "<collection type=\"%s\" num=\"%d\"", type, num);
1823         if (reason)
1824                 fprintf (heap_dump_file, " reason=\"%s\"", reason);
1825         fprintf (heap_dump_file, ">\n");
1826         fprintf (heap_dump_file, "<other-mem-usage type=\"mempools\" size=\"%ld\"/>\n", mono_mempool_get_bytes_allocated ());
1827         sgen_dump_internal_mem_usage (heap_dump_file);
1828         fprintf (heap_dump_file, "<pinned type=\"stack\" bytes=\"%zu\"/>\n", sgen_pin_stats_get_pinned_byte_count (PIN_TYPE_STACK));
1829         /* fprintf (heap_dump_file, "<pinned type=\"static-data\" bytes=\"%d\"/>\n", pinned_byte_counts [PIN_TYPE_STATIC_DATA]); */
1830         fprintf (heap_dump_file, "<pinned type=\"other\" bytes=\"%zu\"/>\n", sgen_pin_stats_get_pinned_byte_count (PIN_TYPE_OTHER));
1831
1832         fprintf (heap_dump_file, "<pinned-objects>\n");
1833         for (list = sgen_pin_stats_get_object_list (); list; list = list->next)
1834                 dump_object (list->obj, TRUE);
1835         fprintf (heap_dump_file, "</pinned-objects>\n");
1836
1837         sgen_dump_section (nursery_section, "nursery");
1838
1839         major_collector.dump_heap (heap_dump_file);
1840
1841         fprintf (heap_dump_file, "<los>\n");
1842         for (bigobj = los_object_list; bigobj; bigobj = bigobj->next)
1843                 dump_object ((MonoObject*)bigobj->data, FALSE);
1844         fprintf (heap_dump_file, "</los>\n");
1845
1846         fprintf (heap_dump_file, "</collection>\n");
1847 }
1848
1849 void
1850 sgen_register_moved_object (void *obj, void *destination)
1851 {
1852         g_assert (mono_profiler_events & MONO_PROFILE_GC_MOVES);
1853
1854         if (moved_objects_idx == MOVED_OBJECTS_NUM) {
1855                 mono_profiler_gc_moves (moved_objects, moved_objects_idx);
1856                 moved_objects_idx = 0;
1857         }
1858         moved_objects [moved_objects_idx++] = obj;
1859         moved_objects [moved_objects_idx++] = destination;
1860 }
1861
1862 static void
1863 init_stats (void)
1864 {
1865         static gboolean inited = FALSE;
1866
1867         if (inited)
1868                 return;
1869
1870         mono_counters_register ("Collection max time",  MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME | MONO_COUNTER_MONOTONIC, &time_max);
1871
1872         mono_counters_register ("Minor fragment clear", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_pre_collection_fragment_clear);
1873         mono_counters_register ("Minor pinning", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_pinning);
1874         mono_counters_register ("Minor scan remembered set", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_scan_remsets);
1875         mono_counters_register ("Minor scan pinned", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_scan_pinned);
1876         mono_counters_register ("Minor scan roots", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_scan_roots);
1877         mono_counters_register ("Minor fragment creation", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_minor_fragment_creation);
1878
1879         mono_counters_register ("Major fragment clear", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_pre_collection_fragment_clear);
1880         mono_counters_register ("Major pinning", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_pinning);
1881         mono_counters_register ("Major scan pinned", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_scan_pinned);
1882         mono_counters_register ("Major scan roots", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_scan_roots);
1883         mono_counters_register ("Major scan mod union", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_scan_mod_union);
1884         mono_counters_register ("Major finish gray stack", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_finish_gray_stack);
1885         mono_counters_register ("Major free big objects", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_free_bigobjs);
1886         mono_counters_register ("Major LOS sweep", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_los_sweep);
1887         mono_counters_register ("Major sweep", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_sweep);
1888         mono_counters_register ("Major fragment creation", MONO_COUNTER_GC | MONO_COUNTER_ULONG | MONO_COUNTER_TIME, &time_major_fragment_creation);
1889
1890         mono_counters_register ("Number of pinned objects", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_pinned_objects);
1891
1892 #ifdef HEAVY_STATISTICS
1893         mono_counters_register ("WBarrier remember pointer", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_add_to_global_remset);
1894         mono_counters_register ("WBarrier set field", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_set_field);
1895         mono_counters_register ("WBarrier set arrayref", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_set_arrayref);
1896         mono_counters_register ("WBarrier arrayref copy", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_arrayref_copy);
1897         mono_counters_register ("WBarrier generic store called", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_generic_store);
1898         mono_counters_register ("WBarrier generic atomic store called", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_generic_store_atomic);
1899         mono_counters_register ("WBarrier set root", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_set_root);
1900         mono_counters_register ("WBarrier value copy", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_value_copy);
1901         mono_counters_register ("WBarrier object copy", MONO_COUNTER_GC | MONO_COUNTER_INT, &stat_wbarrier_object_copy);
1902
1903         mono_counters_register ("# objects allocated degraded", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_objects_alloced_degraded);
1904         mono_counters_register ("bytes allocated degraded", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_bytes_alloced_degraded);
1905
1906         mono_counters_register ("# copy_object() called (nursery)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_copy_object_called_nursery);
1907         mono_counters_register ("# objects copied (nursery)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_objects_copied_nursery);
1908         mono_counters_register ("# copy_object() called (major)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_copy_object_called_major);
1909         mono_counters_register ("# objects copied (major)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_objects_copied_major);
1910
1911         mono_counters_register ("# scan_object() called (nursery)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_scan_object_called_nursery);
1912         mono_counters_register ("# scan_object() called (major)", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_scan_object_called_major);
1913
1914         mono_counters_register ("Slots allocated in vain", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_slots_allocated_in_vain);
1915
1916         mono_counters_register ("# nursery copy_object() failed from space", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_nursery_copy_object_failed_from_space);
1917         mono_counters_register ("# nursery copy_object() failed forwarded", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_nursery_copy_object_failed_forwarded);
1918         mono_counters_register ("# nursery copy_object() failed pinned", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_nursery_copy_object_failed_pinned);
1919         mono_counters_register ("# nursery copy_object() failed to space", MONO_COUNTER_GC | MONO_COUNTER_ULONG, &stat_nursery_copy_object_failed_to_space);
1920
1921         sgen_nursery_allocator_init_heavy_stats ();
1922         sgen_alloc_init_heavy_stats ();
1923 #endif
1924
1925         inited = TRUE;
1926 }
1927
1928
1929 static void
1930 reset_pinned_from_failed_allocation (void)
1931 {
1932         bytes_pinned_from_failed_allocation = 0;
1933 }
1934
1935 void
1936 sgen_set_pinned_from_failed_allocation (mword objsize)
1937 {
1938         bytes_pinned_from_failed_allocation += objsize;
1939 }
1940
1941 gboolean
1942 sgen_collection_is_concurrent (void)
1943 {
1944         switch (current_collection_generation) {
1945         case GENERATION_NURSERY:
1946                 return FALSE;
1947         case GENERATION_OLD:
1948                 return concurrent_collection_in_progress;
1949         default:
1950                 g_error ("Invalid current generation %d", current_collection_generation);
1951         }
1952 }
1953
1954 gboolean
1955 sgen_concurrent_collection_in_progress (void)
1956 {
1957         return concurrent_collection_in_progress;
1958 }
1959
1960 typedef struct {
1961         SgenThreadPoolJob job;
1962         SgenObjectOperations *ops;
1963 } ScanJob;
1964
1965 static void
1966 job_remembered_set_scan (void *worker_data_untyped, SgenThreadPoolJob *job)
1967 {
1968         WorkerData *worker_data = worker_data_untyped;
1969         ScanJob *job_data = (ScanJob*)job;
1970         ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
1971         remset.scan_remsets (ctx);
1972 }
1973
1974 typedef struct {
1975         SgenThreadPoolJob job;
1976         SgenObjectOperations *ops;
1977         char *heap_start;
1978         char *heap_end;
1979         int root_type;
1980 } ScanFromRegisteredRootsJob;
1981
1982 static void
1983 job_scan_from_registered_roots (void *worker_data_untyped, SgenThreadPoolJob *job)
1984 {
1985         WorkerData *worker_data = worker_data_untyped;
1986         ScanFromRegisteredRootsJob *job_data = (ScanFromRegisteredRootsJob*)job;
1987         ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
1988
1989         scan_from_registered_roots (job_data->heap_start, job_data->heap_end, job_data->root_type, ctx);
1990 }
1991
1992 typedef struct {
1993         SgenThreadPoolJob job;
1994         SgenObjectOperations *ops;
1995         char *heap_start;
1996         char *heap_end;
1997 } ScanThreadDataJob;
1998
1999 static void
2000 job_scan_thread_data (void *worker_data_untyped, SgenThreadPoolJob *job)
2001 {
2002         WorkerData *worker_data = worker_data_untyped;
2003         ScanThreadDataJob *job_data = (ScanThreadDataJob*)job;
2004         ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
2005
2006         scan_thread_data (job_data->heap_start, job_data->heap_end, TRUE, ctx);
2007 }
2008
2009 typedef struct {
2010         SgenThreadPoolJob job;
2011         SgenObjectOperations *ops;
2012         FinalizeReadyEntry *list;
2013 } ScanFinalizerEntriesJob;
2014
2015 static void
2016 job_scan_finalizer_entries (void *worker_data_untyped, SgenThreadPoolJob *job)
2017 {
2018         WorkerData *worker_data = worker_data_untyped;
2019         ScanFinalizerEntriesJob *job_data = (ScanFinalizerEntriesJob*)job;
2020         ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
2021
2022         scan_finalizer_entries (job_data->list, ctx);
2023 }
2024
2025 static void
2026 job_scan_major_mod_union_card_table (void *worker_data_untyped, SgenThreadPoolJob *job)
2027 {
2028         WorkerData *worker_data = worker_data_untyped;
2029         ScanJob *job_data = (ScanJob*)job;
2030         ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
2031
2032         g_assert (concurrent_collection_in_progress);
2033         major_collector.scan_card_table (TRUE, ctx);
2034 }
2035
2036 static void
2037 job_scan_los_mod_union_card_table (void *worker_data_untyped, SgenThreadPoolJob *job)
2038 {
2039         WorkerData *worker_data = worker_data_untyped;
2040         ScanJob *job_data = (ScanJob*)job;
2041         ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (job_data->ops, sgen_workers_get_job_gray_queue (worker_data));
2042
2043         g_assert (concurrent_collection_in_progress);
2044         sgen_los_scan_card_table (TRUE, ctx);
2045 }
2046
2047 static void
2048 verify_scan_starts (char *start, char *end)
2049 {
2050         size_t i;
2051
2052         for (i = 0; i < nursery_section->num_scan_start; ++i) {
2053                 char *addr = nursery_section->scan_starts [i];
2054                 if (addr > start && addr < end)
2055                         SGEN_LOG (1, "NFC-BAD SCAN START [%zu] %p for obj [%p %p]", i, addr, start, end);
2056         }
2057 }
2058
2059 static void
2060 verify_nursery (void)
2061 {
2062         char *start, *end, *cur, *hole_start;
2063
2064         if (!do_verify_nursery)
2065                 return;
2066
2067         if (nursery_canaries_enabled ())
2068                 SGEN_LOG (1, "Checking nursery canaries...");
2069
2070         /*This cleans up unused fragments */
2071         sgen_nursery_allocator_prepare_for_pinning ();
2072
2073         hole_start = start = cur = sgen_get_nursery_start ();
2074         end = sgen_get_nursery_end ();
2075
2076         while (cur < end) {
2077                 size_t ss, size;
2078
2079                 if (!*(void**)cur) {
2080                         cur += sizeof (void*);
2081                         continue;
2082                 }
2083
2084                 if (object_is_forwarded (cur))
2085                         SGEN_LOG (1, "FORWARDED OBJ %p", cur);
2086                 else if (object_is_pinned (cur))
2087                         SGEN_LOG (1, "PINNED OBJ %p", cur);
2088
2089                 ss = safe_object_get_size ((MonoObject*)cur);
2090                 size = ALIGN_UP (safe_object_get_size ((MonoObject*)cur));
2091                 verify_scan_starts (cur, cur + size);
2092                 if (do_dump_nursery_content) {
2093                         if (cur > hole_start)
2094                                 SGEN_LOG (1, "HOLE [%p %p %d]", hole_start, cur, (int)(cur - hole_start));
2095                         SGEN_LOG (1, "OBJ  [%p %p %d %d %s %d]", cur, cur + size, (int)size, (int)ss, sgen_safe_name ((MonoObject*)cur), (gpointer)LOAD_VTABLE (cur) == sgen_get_array_fill_vtable ());
2096                 }
2097                 if (nursery_canaries_enabled () && (MonoVTable*)SGEN_LOAD_VTABLE (cur) != array_fill_vtable) {
2098                         CHECK_CANARY_FOR_OBJECT (cur);
2099                         CANARIFY_SIZE (size);
2100                 }
2101                 cur += size;
2102                 hole_start = cur;
2103         }
2104 }
2105
2106 /*
2107  * Checks that no objects in the nursery are fowarded or pinned.  This
2108  * is a precondition to restarting the mutator while doing a
2109  * concurrent collection.  Note that we don't clear fragments because
2110  * we depend on that having happened earlier.
2111  */
2112 static void
2113 check_nursery_is_clean (void)
2114 {
2115         char *end, *cur;
2116
2117         cur = sgen_get_nursery_start ();
2118         end = sgen_get_nursery_end ();
2119
2120         while (cur < end) {
2121                 size_t size;
2122
2123                 if (!*(void**)cur) {
2124                         cur += sizeof (void*);
2125                         continue;
2126                 }
2127
2128                 g_assert (!object_is_forwarded (cur));
2129                 g_assert (!object_is_pinned (cur));
2130
2131                 size = ALIGN_UP (safe_object_get_size ((MonoObject*)cur));
2132                 verify_scan_starts (cur, cur + size);
2133
2134                 cur += size;
2135         }
2136 }
2137
2138 static void
2139 init_gray_queue (void)
2140 {
2141         if (sgen_collection_is_concurrent ())
2142                 sgen_workers_init_distribute_gray_queue ();
2143         sgen_gray_object_queue_init (&gray_queue, NULL);
2144 }
2145
2146 static void
2147 enqueue_scan_from_roots_jobs (char *heap_start, char *heap_end, SgenObjectOperations *ops)
2148 {
2149         ScanFromRegisteredRootsJob *scrrj;
2150         ScanThreadDataJob *stdj;
2151         ScanFinalizerEntriesJob *sfej;
2152
2153         /* registered roots, this includes static fields */
2154
2155         scrrj = (ScanFromRegisteredRootsJob*)sgen_thread_pool_job_alloc ("scan from registered roots normal", job_scan_from_registered_roots, sizeof (ScanFromRegisteredRootsJob));
2156         scrrj->ops = ops;
2157         scrrj->heap_start = heap_start;
2158         scrrj->heap_end = heap_end;
2159         scrrj->root_type = ROOT_TYPE_NORMAL;
2160         sgen_workers_enqueue_job (&scrrj->job);
2161
2162         scrrj = (ScanFromRegisteredRootsJob*)sgen_thread_pool_job_alloc ("scan from registered roots wbarrier", job_scan_from_registered_roots, sizeof (ScanFromRegisteredRootsJob));
2163         scrrj->ops = ops;
2164         scrrj->heap_start = heap_start;
2165         scrrj->heap_end = heap_end;
2166         scrrj->root_type = ROOT_TYPE_WBARRIER;
2167         sgen_workers_enqueue_job (&scrrj->job);
2168
2169         /* Threads */
2170
2171         stdj = (ScanThreadDataJob*)sgen_thread_pool_job_alloc ("scan thread data", job_scan_thread_data, sizeof (ScanThreadDataJob));
2172         stdj->heap_start = heap_start;
2173         stdj->heap_end = heap_end;
2174         sgen_workers_enqueue_job (&stdj->job);
2175
2176         /* Scan the list of objects ready for finalization. */
2177
2178         sfej = (ScanFinalizerEntriesJob*)sgen_thread_pool_job_alloc ("scan finalizer entries", job_scan_finalizer_entries, sizeof (ScanFinalizerEntriesJob));
2179         sfej->list = fin_ready_list;
2180         sfej->ops = ops;
2181         sgen_workers_enqueue_job (&sfej->job);
2182
2183         sfej = (ScanFinalizerEntriesJob*)sgen_thread_pool_job_alloc ("scan critical finalizer entries", job_scan_finalizer_entries, sizeof (ScanFinalizerEntriesJob));
2184         sfej->list = critical_fin_list;
2185         sfej->ops = ops;
2186         sgen_workers_enqueue_job (&sfej->job);
2187 }
2188
2189 /*
2190  * Perform a nursery collection.
2191  *
2192  * Return whether any objects were late-pinned due to being out of memory.
2193  */
2194 static gboolean
2195 collect_nursery (SgenGrayQueue *unpin_queue, gboolean finish_up_concurrent_mark)
2196 {
2197         gboolean needs_major;
2198         size_t max_garbage_amount;
2199         char *nursery_next;
2200         mword fragment_total;
2201         ScanJob *sj;
2202         SgenObjectOperations *object_ops = &sgen_minor_collector.serial_ops;
2203         ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (object_ops, &gray_queue);
2204         TV_DECLARE (atv);
2205         TV_DECLARE (btv);
2206
2207         if (disable_minor_collections)
2208                 return TRUE;
2209
2210         TV_GETTIME (last_minor_collection_start_tv);
2211         atv = last_minor_collection_start_tv;
2212
2213         MONO_GC_BEGIN (GENERATION_NURSERY);
2214         binary_protocol_collection_begin (gc_stats.minor_gc_count, GENERATION_NURSERY);
2215
2216         verify_nursery ();
2217
2218 #ifndef DISABLE_PERFCOUNTERS
2219         mono_perfcounters->gc_collections0++;
2220 #endif
2221
2222         current_collection_generation = GENERATION_NURSERY;
2223
2224         SGEN_ASSERT (0, !sgen_collection_is_concurrent (), "Why is the nursery collection concurrent?");
2225
2226         reset_pinned_from_failed_allocation ();
2227
2228         check_scan_starts ();
2229
2230         sgen_nursery_alloc_prepare_for_minor ();
2231
2232         degraded_mode = 0;
2233         objects_pinned = 0;
2234         nursery_next = sgen_nursery_alloc_get_upper_alloc_bound ();
2235         /* FIXME: optimize later to use the higher address where an object can be present */
2236         nursery_next = MAX (nursery_next, sgen_get_nursery_end ());
2237
2238         SGEN_LOG (1, "Start nursery collection %d %p-%p, size: %d", gc_stats.minor_gc_count, sgen_get_nursery_start (), nursery_next, (int)(nursery_next - sgen_get_nursery_start ()));
2239         max_garbage_amount = nursery_next - sgen_get_nursery_start ();
2240         g_assert (nursery_section->size >= max_garbage_amount);
2241
2242         /* world must be stopped already */
2243         TV_GETTIME (btv);
2244         time_minor_pre_collection_fragment_clear += TV_ELAPSED (atv, btv);
2245
2246         if (xdomain_checks) {
2247                 sgen_clear_nursery_fragments ();
2248                 sgen_check_for_xdomain_refs ();
2249         }
2250
2251         nursery_section->next_data = nursery_next;
2252
2253         major_collector.start_nursery_collection ();
2254
2255         sgen_memgov_minor_collection_start ();
2256
2257         init_gray_queue ();
2258
2259         gc_stats.minor_gc_count ++;
2260
2261         if (whole_heap_check_before_collection) {
2262                 sgen_clear_nursery_fragments ();
2263                 sgen_check_whole_heap (finish_up_concurrent_mark);
2264         }
2265         if (consistency_check_at_minor_collection)
2266                 sgen_check_consistency ();
2267
2268         MONO_GC_CHECKPOINT_1 (GENERATION_NURSERY);
2269
2270         sgen_process_fin_stage_entries ();
2271         sgen_process_dislink_stage_entries ();
2272
2273         MONO_GC_CHECKPOINT_2 (GENERATION_NURSERY);
2274
2275         /* pin from pinned handles */
2276         sgen_init_pinning ();
2277         mono_profiler_gc_event (MONO_GC_EVENT_MARK_START, 0);
2278         pin_from_roots (sgen_get_nursery_start (), nursery_next, ctx);
2279         /* pin cemented objects */
2280         sgen_pin_cemented_objects ();
2281         /* identify pinned objects */
2282         sgen_optimize_pin_queue ();
2283         sgen_pinning_setup_section (nursery_section);
2284
2285         pin_objects_in_nursery (FALSE, ctx);
2286         sgen_pinning_trim_queue_to_section (nursery_section);
2287
2288         TV_GETTIME (atv);
2289         time_minor_pinning += TV_ELAPSED (btv, atv);
2290         SGEN_LOG (2, "Finding pinned pointers: %zd in %d usecs", sgen_get_pinned_count (), TV_ELAPSED (btv, atv));
2291         SGEN_LOG (4, "Start scan with %zd pinned objects", sgen_get_pinned_count ());
2292
2293         MONO_GC_CHECKPOINT_3 (GENERATION_NURSERY);
2294
2295         /*
2296          * FIXME: When we finish a concurrent collection we do a nursery collection first,
2297          * as part of which we scan the card table.  Then, later, we scan the mod union
2298          * cardtable.  We should only have to do one.
2299          */
2300         sj = (ScanJob*)sgen_thread_pool_job_alloc ("scan remset", job_remembered_set_scan, sizeof (ScanJob));
2301         sj->ops = object_ops;
2302         sgen_workers_enqueue_job (&sj->job);
2303
2304         /* we don't have complete write barrier yet, so we scan all the old generation sections */
2305         TV_GETTIME (btv);
2306         time_minor_scan_remsets += TV_ELAPSED (atv, btv);
2307         SGEN_LOG (2, "Old generation scan: %d usecs", TV_ELAPSED (atv, btv));
2308
2309         MONO_GC_CHECKPOINT_4 (GENERATION_NURSERY);
2310
2311         sgen_drain_gray_stack (-1, ctx);
2312
2313         if (mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS)
2314                 report_registered_roots ();
2315         if (mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS)
2316                 report_finalizer_roots ();
2317         TV_GETTIME (atv);
2318         time_minor_scan_pinned += TV_ELAPSED (btv, atv);
2319
2320         MONO_GC_CHECKPOINT_5 (GENERATION_NURSERY);
2321
2322         enqueue_scan_from_roots_jobs (sgen_get_nursery_start (), nursery_next, object_ops);
2323
2324         TV_GETTIME (btv);
2325         time_minor_scan_roots += TV_ELAPSED (atv, btv);
2326
2327         MONO_GC_CHECKPOINT_6 (GENERATION_NURSERY);
2328         MONO_GC_CHECKPOINT_7 (GENERATION_NURSERY);
2329         MONO_GC_CHECKPOINT_8 (GENERATION_NURSERY);
2330
2331         finish_gray_stack (GENERATION_NURSERY, ctx);
2332         TV_GETTIME (atv);
2333         time_minor_finish_gray_stack += TV_ELAPSED (btv, atv);
2334         mono_profiler_gc_event (MONO_GC_EVENT_MARK_END, 0);
2335
2336         MONO_GC_CHECKPOINT_9 (GENERATION_NURSERY);
2337
2338         if (objects_pinned) {
2339                 sgen_optimize_pin_queue ();
2340                 sgen_pinning_setup_section (nursery_section);
2341         }
2342
2343         /* walk the pin_queue, build up the fragment list of free memory, unmark
2344          * pinned objects as we go, memzero() the empty fragments so they are ready for the
2345          * next allocations.
2346          */
2347         mono_profiler_gc_event (MONO_GC_EVENT_RECLAIM_START, 0);
2348         fragment_total = sgen_build_nursery_fragments (nursery_section, unpin_queue);
2349         if (!fragment_total)
2350                 degraded_mode = 1;
2351
2352         /* Clear TLABs for all threads */
2353         sgen_clear_tlabs ();
2354
2355         mono_profiler_gc_event (MONO_GC_EVENT_RECLAIM_END, 0);
2356         TV_GETTIME (btv);
2357         time_minor_fragment_creation += TV_ELAPSED (atv, btv);
2358         SGEN_LOG (2, "Fragment creation: %d usecs, %lu bytes available", TV_ELAPSED (atv, btv), (unsigned long)fragment_total);
2359
2360         if (consistency_check_at_minor_collection)
2361                 sgen_check_major_refs ();
2362
2363         major_collector.finish_nursery_collection ();
2364
2365         TV_GETTIME (last_minor_collection_end_tv);
2366         gc_stats.minor_gc_time += TV_ELAPSED (last_minor_collection_start_tv, last_minor_collection_end_tv);
2367
2368         if (heap_dump_file)
2369                 dump_heap ("minor", gc_stats.minor_gc_count - 1, NULL);
2370
2371         /* prepare the pin queue for the next collection */
2372         sgen_finish_pinning ();
2373         if (fin_ready_list || critical_fin_list) {
2374                 SGEN_LOG (4, "Finalizer-thread wakeup: ready %d", num_ready_finalizers);
2375                 mono_gc_finalize_notify ();
2376         }
2377         sgen_pin_stats_reset ();
2378         /* clear cemented hash */
2379         sgen_cement_clear_below_threshold ();
2380
2381         g_assert (sgen_gray_object_queue_is_empty (&gray_queue));
2382
2383         remset.finish_minor_collection ();
2384
2385         check_scan_starts ();
2386
2387         binary_protocol_flush_buffers (FALSE);
2388
2389         sgen_memgov_minor_collection_end ();
2390
2391         /*objects are late pinned because of lack of memory, so a major is a good call*/
2392         needs_major = objects_pinned > 0;
2393         current_collection_generation = -1;
2394         objects_pinned = 0;
2395
2396         MONO_GC_END (GENERATION_NURSERY);
2397         binary_protocol_collection_end (gc_stats.minor_gc_count - 1, GENERATION_NURSERY, 0, 0);
2398
2399         if (check_nursery_objects_pinned && !sgen_minor_collector.is_split)
2400                 sgen_check_nursery_objects_pinned (unpin_queue != NULL);
2401
2402         return needs_major;
2403 }
2404
2405 static void
2406 scan_nursery_objects_callback (char *obj, size_t size, ScanCopyContext *ctx)
2407 {
2408         /*
2409          * This is called on all objects in the nursery, including pinned ones, so we need
2410          * to use sgen_obj_get_descriptor_safe(), which masks out the vtable tag bits.
2411          */
2412         ctx->ops->scan_object (obj, sgen_obj_get_descriptor_safe (obj), ctx->queue);
2413 }
2414
2415 static void
2416 scan_nursery_objects (ScanCopyContext ctx)
2417 {
2418         sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data,
2419                         (IterateObjectCallbackFunc)scan_nursery_objects_callback, (void*)&ctx, FALSE);
2420 }
2421
2422 typedef enum {
2423         COPY_OR_MARK_FROM_ROOTS_SERIAL,
2424         COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT,
2425         COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT
2426 } CopyOrMarkFromRootsMode;
2427
2428 static void
2429 major_copy_or_mark_from_roots (size_t *old_next_pin_slot, CopyOrMarkFromRootsMode mode, gboolean scan_whole_nursery, SgenObjectOperations *object_ops)
2430 {
2431         LOSObject *bigobj;
2432         TV_DECLARE (atv);
2433         TV_DECLARE (btv);
2434         /* FIXME: only use these values for the precise scan
2435          * note that to_space pointers should be excluded anyway...
2436          */
2437         char *heap_start = NULL;
2438         char *heap_end = (char*)-1;
2439         gboolean profile_roots = mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS;
2440         GCRootReport root_report = { 0 };
2441         ScanCopyContext ctx = CONTEXT_FROM_OBJECT_OPERATIONS (object_ops, WORKERS_DISTRIBUTE_GRAY_QUEUE);
2442         gboolean concurrent = mode != COPY_OR_MARK_FROM_ROOTS_SERIAL;
2443
2444         SGEN_ASSERT (0, !!concurrent == !!concurrent_collection_in_progress, "We've been called with the wrong mode.");
2445
2446         if (scan_whole_nursery)
2447                 SGEN_ASSERT (0, mode == COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT, "Scanning whole nursery only makes sense when we're finishing a concurrent collection.");
2448
2449         if (concurrent) {
2450                 /*This cleans up unused fragments */
2451                 sgen_nursery_allocator_prepare_for_pinning ();
2452
2453                 if (do_concurrent_checks)
2454                         check_nursery_is_clean ();
2455         } else {
2456                 /* The concurrent collector doesn't touch the nursery. */
2457                 sgen_nursery_alloc_prepare_for_major ();
2458         }
2459
2460         init_gray_queue ();
2461
2462         TV_GETTIME (atv);
2463
2464         /* Pinning depends on this */
2465         sgen_clear_nursery_fragments ();
2466
2467         if (whole_heap_check_before_collection)
2468                 sgen_check_whole_heap (mode == COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT);
2469
2470         TV_GETTIME (btv);
2471         time_major_pre_collection_fragment_clear += TV_ELAPSED (atv, btv);
2472
2473         if (!sgen_collection_is_concurrent ())
2474                 nursery_section->next_data = sgen_get_nursery_end ();
2475         /* we should also coalesce scanning from sections close to each other
2476          * and deal with pointers outside of the sections later.
2477          */
2478
2479         objects_pinned = 0;
2480
2481         if (xdomain_checks) {
2482                 sgen_clear_nursery_fragments ();
2483                 sgen_check_for_xdomain_refs ();
2484         }
2485
2486         if (!concurrent) {
2487                 /* Remsets are not useful for a major collection */
2488                 remset.clear_cards ();
2489         }
2490
2491         sgen_process_fin_stage_entries ();
2492         sgen_process_dislink_stage_entries ();
2493
2494         TV_GETTIME (atv);
2495         sgen_init_pinning ();
2496         SGEN_LOG (6, "Collecting pinned addresses");
2497         pin_from_roots ((void*)lowest_heap_address, (void*)highest_heap_address, ctx);
2498
2499         if (mode != COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT) {
2500                 if (major_collector.is_concurrent) {
2501                         /*
2502                          * The concurrent major collector cannot evict
2503                          * yet, so we need to pin cemented objects to
2504                          * not break some asserts.
2505                          *
2506                          * FIXME: We could evict now!
2507                          */
2508                         sgen_pin_cemented_objects ();
2509                 }
2510         }
2511
2512         sgen_optimize_pin_queue ();
2513
2514         /*
2515          * pin_queue now contains all candidate pointers, sorted and
2516          * uniqued.  We must do two passes now to figure out which
2517          * objects are pinned.
2518          *
2519          * The first is to find within the pin_queue the area for each
2520          * section.  This requires that the pin_queue be sorted.  We
2521          * also process the LOS objects and pinned chunks here.
2522          *
2523          * The second, destructive, pass is to reduce the section
2524          * areas to pointers to the actually pinned objects.
2525          */
2526         SGEN_LOG (6, "Pinning from sections");
2527         /* first pass for the sections */
2528         sgen_find_section_pin_queue_start_end (nursery_section);
2529         /* identify possible pointers to the insize of large objects */
2530         SGEN_LOG (6, "Pinning from large objects");
2531         for (bigobj = los_object_list; bigobj; bigobj = bigobj->next) {
2532                 size_t dummy;
2533                 if (sgen_find_optimized_pin_queue_area (bigobj->data, (char*)bigobj->data + sgen_los_object_size (bigobj), &dummy, &dummy)) {
2534                         binary_protocol_pin (bigobj->data, (gpointer)LOAD_VTABLE (bigobj->data), safe_object_get_size (((MonoObject*)(bigobj->data))));
2535
2536 #ifdef ENABLE_DTRACE
2537                         if (G_UNLIKELY (MONO_GC_OBJ_PINNED_ENABLED ())) {
2538                                 MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (bigobj->data);
2539                                 MONO_GC_OBJ_PINNED ((mword)bigobj->data, sgen_safe_object_get_size ((MonoObject*)bigobj->data), vt->klass->name_space, vt->klass->name, GENERATION_OLD);
2540                         }
2541 #endif
2542
2543                         if (sgen_los_object_is_pinned (bigobj->data)) {
2544                                 SGEN_ASSERT (0, mode == COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT, "LOS objects can only be pinned here after concurrent marking.");
2545                                 continue;
2546                         }
2547                         sgen_los_pin_object (bigobj->data);
2548                         if (SGEN_OBJECT_HAS_REFERENCES (bigobj->data))
2549                                 GRAY_OBJECT_ENQUEUE (WORKERS_DISTRIBUTE_GRAY_QUEUE, bigobj->data, sgen_obj_get_descriptor (bigobj->data));
2550                         sgen_pin_stats_register_object ((char*) bigobj->data, safe_object_get_size ((MonoObject*) bigobj->data));
2551                         SGEN_LOG (6, "Marked large object %p (%s) size: %lu from roots", bigobj->data, safe_name (bigobj->data), (unsigned long)sgen_los_object_size (bigobj));
2552
2553                         if (profile_roots)
2554                                 add_profile_gc_root (&root_report, bigobj->data, MONO_PROFILE_GC_ROOT_PINNING | MONO_PROFILE_GC_ROOT_MISC, 0);
2555                 }
2556         }
2557         if (profile_roots)
2558                 notify_gc_roots (&root_report);
2559         /* second pass for the sections */
2560
2561         /*
2562          * Concurrent mark never follows references into the nursery.  In the start and
2563          * finish pauses we must scan live nursery objects, though.
2564          *
2565          * In the finish pause we do this conservatively by scanning all nursery objects.
2566          * Previously we would only scan pinned objects here.  We assumed that all objects
2567          * that were pinned during the nursery collection immediately preceding this finish
2568          * mark would be pinned again here.  Due to the way we get the stack end for the GC
2569          * thread, however, that's not necessarily the case: we scan part of the stack used
2570          * by the GC itself, which changes constantly, so pinning isn't entirely
2571          * deterministic.
2572          *
2573          * The split nursery also complicates things because non-pinned objects can survive
2574          * in the nursery.  That's why we need to do a full scan of the nursery for it, too.
2575          *
2576          * In the future we shouldn't do a preceding nursery collection at all and instead
2577          * do the finish pause with promotion from the nursery.
2578          *
2579          * A further complication arises when we have late-pinned objects from the preceding
2580          * nursery collection.  Those are the result of being out of memory when trying to
2581          * evacuate objects.  They won't be found from the roots, so we just scan the whole
2582          * nursery.
2583          *
2584          * Non-concurrent mark evacuates from the nursery, so it's
2585          * sufficient to just scan pinned nursery objects.
2586          */
2587         if (scan_whole_nursery || mode == COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT || (concurrent && sgen_minor_collector.is_split)) {
2588                 scan_nursery_objects (ctx);
2589         } else {
2590                 pin_objects_in_nursery (concurrent, ctx);
2591                 if (check_nursery_objects_pinned && !sgen_minor_collector.is_split)
2592                         sgen_check_nursery_objects_pinned (mode != COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT);
2593         }
2594
2595         major_collector.pin_objects (WORKERS_DISTRIBUTE_GRAY_QUEUE);
2596         if (old_next_pin_slot)
2597                 *old_next_pin_slot = sgen_get_pinned_count ();
2598
2599         TV_GETTIME (btv);
2600         time_major_pinning += TV_ELAPSED (atv, btv);
2601         SGEN_LOG (2, "Finding pinned pointers: %zd in %d usecs", sgen_get_pinned_count (), TV_ELAPSED (atv, btv));
2602         SGEN_LOG (4, "Start scan with %zd pinned objects", sgen_get_pinned_count ());
2603
2604         major_collector.init_to_space ();
2605
2606         /*
2607          * The concurrent collector doesn't move objects, neither on
2608          * the major heap nor in the nursery, so we can mark even
2609          * before pinning has finished.  For the non-concurrent
2610          * collector we start the workers after pinning.
2611          */
2612         if (mode != COPY_OR_MARK_FROM_ROOTS_SERIAL) {
2613                 SGEN_ASSERT (0, sgen_workers_all_done (), "Why are the workers not done when we start or finish a major collection?");
2614                 sgen_workers_start_all_workers (object_ops);
2615                 gray_queue_enable_redirect (WORKERS_DISTRIBUTE_GRAY_QUEUE);
2616         }
2617
2618 #ifdef SGEN_DEBUG_INTERNAL_ALLOC
2619         main_gc_thread = mono_native_thread_self ();
2620 #endif
2621
2622         if (mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS)
2623                 report_registered_roots ();
2624         TV_GETTIME (atv);
2625         time_major_scan_pinned += TV_ELAPSED (btv, atv);
2626
2627         if (mono_profiler_get_events () & MONO_PROFILE_GC_ROOTS)
2628                 report_finalizer_roots ();
2629
2630         /*
2631          * FIXME: is this the right context?  It doesn't seem to contain a copy function
2632          * unless we're concurrent.
2633          */
2634         enqueue_scan_from_roots_jobs (heap_start, heap_end, object_ops);
2635
2636         TV_GETTIME (btv);
2637         time_major_scan_roots += TV_ELAPSED (atv, btv);
2638
2639         if (mode == COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT) {
2640                 ScanJob *sj;
2641
2642                 /* Mod union card table */
2643                 sj = (ScanJob*)sgen_thread_pool_job_alloc ("scan mod union cardtable", job_scan_major_mod_union_card_table, sizeof (ScanJob));
2644                 sj->ops = object_ops;
2645                 sgen_workers_enqueue_job (&sj->job);
2646
2647                 sj = (ScanJob*)sgen_thread_pool_job_alloc ("scan LOS mod union cardtable", job_scan_los_mod_union_card_table, sizeof (ScanJob));
2648                 sj->ops = object_ops;
2649                 sgen_workers_enqueue_job (&sj->job);
2650
2651                 TV_GETTIME (atv);
2652                 time_major_scan_mod_union += TV_ELAPSED (btv, atv);
2653         }
2654 }
2655
2656 static void
2657 major_finish_copy_or_mark (void)
2658 {
2659         if (!concurrent_collection_in_progress)
2660                 return;
2661
2662         /*
2663          * Prepare the pin queue for the next collection.  Since pinning runs on the worker
2664          * threads we must wait for the jobs to finish before we can reset it.
2665          */
2666         sgen_workers_wait_for_jobs_finished ();
2667         sgen_finish_pinning ();
2668
2669         sgen_pin_stats_reset ();
2670
2671         if (do_concurrent_checks)
2672                 check_nursery_is_clean ();
2673 }
2674
2675 static void
2676 major_start_collection (gboolean concurrent, size_t *old_next_pin_slot)
2677 {
2678         SgenObjectOperations *object_ops;
2679
2680         MONO_GC_BEGIN (GENERATION_OLD);
2681         binary_protocol_collection_begin (gc_stats.major_gc_count, GENERATION_OLD);
2682
2683         current_collection_generation = GENERATION_OLD;
2684 #ifndef DISABLE_PERFCOUNTERS
2685         mono_perfcounters->gc_collections1++;
2686 #endif
2687
2688         g_assert (sgen_section_gray_queue_is_empty (sgen_workers_get_distribute_section_gray_queue ()));
2689
2690         sgen_cement_reset ();
2691
2692         if (concurrent) {
2693                 g_assert (major_collector.is_concurrent);
2694                 concurrent_collection_in_progress = TRUE;
2695
2696                 object_ops = &major_collector.major_ops_concurrent_start;
2697         } else {
2698                 object_ops = &major_collector.major_ops_serial;
2699         }
2700
2701         reset_pinned_from_failed_allocation ();
2702
2703         sgen_memgov_major_collection_start ();
2704
2705         //count_ref_nonref_objs ();
2706         //consistency_check ();
2707
2708         check_scan_starts ();
2709
2710         degraded_mode = 0;
2711         SGEN_LOG (1, "Start major collection %d", gc_stats.major_gc_count);
2712         gc_stats.major_gc_count ++;
2713
2714         if (major_collector.start_major_collection)
2715                 major_collector.start_major_collection ();
2716
2717         major_copy_or_mark_from_roots (old_next_pin_slot, concurrent ? COPY_OR_MARK_FROM_ROOTS_START_CONCURRENT : COPY_OR_MARK_FROM_ROOTS_SERIAL, FALSE, object_ops);
2718         major_finish_copy_or_mark ();
2719 }
2720
2721 static void
2722 major_finish_collection (const char *reason, size_t old_next_pin_slot, gboolean forced, gboolean scan_whole_nursery)
2723 {
2724         ScannedObjectCounts counts;
2725         SgenObjectOperations *object_ops;
2726         TV_DECLARE (atv);
2727         TV_DECLARE (btv);
2728
2729         TV_GETTIME (btv);
2730
2731         if (concurrent_collection_in_progress) {
2732                 object_ops = &major_collector.major_ops_concurrent_finish;
2733
2734                 major_copy_or_mark_from_roots (NULL, COPY_OR_MARK_FROM_ROOTS_FINISH_CONCURRENT, scan_whole_nursery, object_ops);
2735
2736                 major_finish_copy_or_mark ();
2737
2738                 sgen_workers_join ();
2739
2740                 SGEN_ASSERT (0, sgen_gray_object_queue_is_empty (&gray_queue), "Why is the gray queue not empty after workers have finished working?");
2741
2742 #ifdef SGEN_DEBUG_INTERNAL_ALLOC
2743                 main_gc_thread = NULL;
2744 #endif
2745
2746                 if (do_concurrent_checks)
2747                         check_nursery_is_clean ();
2748         } else {
2749                 SGEN_ASSERT (0, !scan_whole_nursery, "scan_whole_nursery only applies to concurrent collections");
2750                 object_ops = &major_collector.major_ops_serial;
2751         }
2752
2753         /*
2754          * The workers have stopped so we need to finish gray queue
2755          * work that might result from finalization in the main GC
2756          * thread.  Redirection must therefore be turned off.
2757          */
2758         sgen_gray_object_queue_disable_alloc_prepare (&gray_queue);
2759         g_assert (sgen_section_gray_queue_is_empty (sgen_workers_get_distribute_section_gray_queue ()));
2760
2761         /* all the objects in the heap */
2762         finish_gray_stack (GENERATION_OLD, CONTEXT_FROM_OBJECT_OPERATIONS (object_ops, &gray_queue));
2763         TV_GETTIME (atv);
2764         time_major_finish_gray_stack += TV_ELAPSED (btv, atv);
2765
2766         SGEN_ASSERT (0, sgen_workers_all_done (), "Can't have workers working after joining");
2767
2768         if (objects_pinned) {
2769                 g_assert (!concurrent_collection_in_progress);
2770
2771                 /*
2772                  * This is slow, but we just OOM'd.
2773                  *
2774                  * See comment at `sgen_pin_queue_clear_discarded_entries` for how the pin
2775                  * queue is laid out at this point.
2776                  */
2777                 sgen_pin_queue_clear_discarded_entries (nursery_section, old_next_pin_slot);
2778                 /*
2779                  * We need to reestablish all pinned nursery objects in the pin queue
2780                  * because they're needed for fragment creation.  Unpinning happens by
2781                  * walking the whole queue, so it's not necessary to reestablish where major
2782                  * heap block pins are - all we care is that they're still in there
2783                  * somewhere.
2784                  */
2785                 sgen_optimize_pin_queue ();
2786                 sgen_find_section_pin_queue_start_end (nursery_section);
2787                 objects_pinned = 0;
2788         }
2789
2790         reset_heap_boundaries ();
2791         sgen_update_heap_boundaries ((mword)sgen_get_nursery_start (), (mword)sgen_get_nursery_end ());
2792
2793         if (!concurrent_collection_in_progress) {
2794                 /* walk the pin_queue, build up the fragment list of free memory, unmark
2795                  * pinned objects as we go, memzero() the empty fragments so they are ready for the
2796                  * next allocations.
2797                  */
2798                 if (!sgen_build_nursery_fragments (nursery_section, NULL))
2799                         degraded_mode = 1;
2800
2801                 /* prepare the pin queue for the next collection */
2802                 sgen_finish_pinning ();
2803
2804                 /* Clear TLABs for all threads */
2805                 sgen_clear_tlabs ();
2806
2807                 sgen_pin_stats_reset ();
2808         }
2809
2810         sgen_cement_clear_below_threshold ();
2811
2812         if (check_mark_bits_after_major_collection)
2813                 sgen_check_heap_marked (concurrent_collection_in_progress);
2814
2815         TV_GETTIME (btv);
2816         time_major_fragment_creation += TV_ELAPSED (atv, btv);
2817
2818         MONO_GC_SWEEP_BEGIN (GENERATION_OLD, !major_collector.sweeps_lazily);
2819
2820         TV_GETTIME (atv);
2821         time_major_free_bigobjs += TV_ELAPSED (btv, atv);
2822
2823         sgen_los_sweep ();
2824
2825         TV_GETTIME (btv);
2826         time_major_los_sweep += TV_ELAPSED (atv, btv);
2827
2828         major_collector.sweep ();
2829
2830         MONO_GC_SWEEP_END (GENERATION_OLD, !major_collector.sweeps_lazily);
2831
2832         TV_GETTIME (atv);
2833         time_major_sweep += TV_ELAPSED (btv, atv);
2834
2835         if (heap_dump_file)
2836                 dump_heap ("major", gc_stats.major_gc_count - 1, reason);
2837
2838         if (fin_ready_list || critical_fin_list) {
2839                 SGEN_LOG (4, "Finalizer-thread wakeup: ready %d", num_ready_finalizers);
2840                 mono_gc_finalize_notify ();
2841         }
2842
2843         g_assert (sgen_gray_object_queue_is_empty (&gray_queue));
2844
2845         sgen_memgov_major_collection_end (forced);
2846         current_collection_generation = -1;
2847
2848         memset (&counts, 0, sizeof (ScannedObjectCounts));
2849         major_collector.finish_major_collection (&counts);
2850
2851         g_assert (sgen_section_gray_queue_is_empty (sgen_workers_get_distribute_section_gray_queue ()));
2852
2853         SGEN_ASSERT (0, sgen_workers_all_done (), "Can't have workers working after major collection has finished");
2854         if (concurrent_collection_in_progress)
2855                 concurrent_collection_in_progress = FALSE;
2856
2857         check_scan_starts ();
2858
2859         binary_protocol_flush_buffers (FALSE);
2860
2861         //consistency_check ();
2862
2863         MONO_GC_END (GENERATION_OLD);
2864         binary_protocol_collection_end (gc_stats.major_gc_count - 1, GENERATION_OLD, counts.num_scanned_objects, counts.num_unique_scanned_objects);
2865 }
2866
2867 static gboolean
2868 major_do_collection (const char *reason, gboolean forced)
2869 {
2870         TV_DECLARE (time_start);
2871         TV_DECLARE (time_end);
2872         size_t old_next_pin_slot;
2873
2874         if (disable_major_collections)
2875                 return FALSE;
2876
2877         if (major_collector.get_and_reset_num_major_objects_marked) {
2878                 long long num_marked = major_collector.get_and_reset_num_major_objects_marked ();
2879                 g_assert (!num_marked);
2880         }
2881
2882         /* world must be stopped already */
2883         TV_GETTIME (time_start);
2884
2885         major_start_collection (FALSE, &old_next_pin_slot);
2886         major_finish_collection (reason, old_next_pin_slot, forced, FALSE);
2887
2888         TV_GETTIME (time_end);
2889         gc_stats.major_gc_time += TV_ELAPSED (time_start, time_end);
2890
2891         /* FIXME: also report this to the user, preferably in gc-end. */
2892         if (major_collector.get_and_reset_num_major_objects_marked)
2893                 major_collector.get_and_reset_num_major_objects_marked ();
2894
2895         return bytes_pinned_from_failed_allocation > 0;
2896 }
2897
2898 static void
2899 major_start_concurrent_collection (const char *reason)
2900 {
2901         TV_DECLARE (time_start);
2902         TV_DECLARE (time_end);
2903         long long num_objects_marked;
2904
2905         if (disable_major_collections)
2906                 return;
2907
2908         TV_GETTIME (time_start);
2909         SGEN_TV_GETTIME (time_major_conc_collection_start);
2910
2911         num_objects_marked = major_collector.get_and_reset_num_major_objects_marked ();
2912         g_assert (num_objects_marked == 0);
2913
2914         MONO_GC_CONCURRENT_START_BEGIN (GENERATION_OLD);
2915         binary_protocol_concurrent_start ();
2916
2917         // FIXME: store reason and pass it when finishing
2918         major_start_collection (TRUE, NULL);
2919
2920         gray_queue_redirect (&gray_queue);
2921
2922         num_objects_marked = major_collector.get_and_reset_num_major_objects_marked ();
2923         MONO_GC_CONCURRENT_START_END (GENERATION_OLD, num_objects_marked);
2924
2925         TV_GETTIME (time_end);
2926         gc_stats.major_gc_time += TV_ELAPSED (time_start, time_end);
2927
2928         current_collection_generation = -1;
2929 }
2930
2931 /*
2932  * Returns whether the major collection has finished.
2933  */
2934 static gboolean
2935 major_should_finish_concurrent_collection (void)
2936 {
2937         SGEN_ASSERT (0, sgen_gray_object_queue_is_empty (&gray_queue), "Why is the gray queue not empty before we have started doing anything?");
2938         return sgen_workers_all_done ();
2939 }
2940
2941 static void
2942 major_update_concurrent_collection (void)
2943 {
2944         TV_DECLARE (total_start);
2945         TV_DECLARE (total_end);
2946
2947         TV_GETTIME (total_start);
2948
2949         MONO_GC_CONCURRENT_UPDATE_FINISH_BEGIN (GENERATION_OLD, major_collector.get_and_reset_num_major_objects_marked ());
2950         binary_protocol_concurrent_update ();
2951
2952         major_collector.update_cardtable_mod_union ();
2953         sgen_los_update_cardtable_mod_union ();
2954
2955         MONO_GC_CONCURRENT_UPDATE_END (GENERATION_OLD, major_collector.get_and_reset_num_major_objects_marked ());
2956
2957         TV_GETTIME (total_end);
2958         gc_stats.major_gc_time += TV_ELAPSED (total_start, total_end);
2959 }
2960
2961 static void
2962 major_finish_concurrent_collection (gboolean forced)
2963 {
2964         TV_DECLARE (total_start);
2965         TV_DECLARE (total_end);
2966         gboolean late_pinned;
2967         SgenGrayQueue unpin_queue;
2968         memset (&unpin_queue, 0, sizeof (unpin_queue));
2969
2970         TV_GETTIME (total_start);
2971
2972         MONO_GC_CONCURRENT_UPDATE_FINISH_BEGIN (GENERATION_OLD, major_collector.get_and_reset_num_major_objects_marked ());
2973         binary_protocol_concurrent_finish ();
2974
2975         /*
2976          * The major collector can add global remsets which are processed in the finishing
2977          * nursery collection, below.  That implies that the workers must have finished
2978          * marking before the nursery collection is allowed to run, otherwise we might miss
2979          * some remsets.
2980          */
2981         sgen_workers_wait ();
2982
2983         SGEN_TV_GETTIME (time_major_conc_collection_end);
2984         gc_stats.major_gc_time_concurrent += SGEN_TV_ELAPSED (time_major_conc_collection_start, time_major_conc_collection_end);
2985
2986         major_collector.update_cardtable_mod_union ();
2987         sgen_los_update_cardtable_mod_union ();
2988
2989         late_pinned = collect_nursery (&unpin_queue, TRUE);
2990
2991         if (mod_union_consistency_check)
2992                 sgen_check_mod_union_consistency ();
2993
2994         current_collection_generation = GENERATION_OLD;
2995         major_finish_collection ("finishing", -1, forced, late_pinned);
2996
2997         if (whole_heap_check_before_collection)
2998                 sgen_check_whole_heap (FALSE);
2999
3000         unpin_objects_from_queue (&unpin_queue);
3001         sgen_gray_object_queue_deinit (&unpin_queue);
3002
3003         MONO_GC_CONCURRENT_FINISH_END (GENERATION_OLD, major_collector.get_and_reset_num_major_objects_marked ());
3004
3005         TV_GETTIME (total_end);
3006         gc_stats.major_gc_time += TV_ELAPSED (total_start, total_end) - TV_ELAPSED (last_minor_collection_start_tv, last_minor_collection_end_tv);
3007
3008         current_collection_generation = -1;
3009 }
3010
3011 /*
3012  * Ensure an allocation request for @size will succeed by freeing enough memory.
3013  *
3014  * LOCKING: The GC lock MUST be held.
3015  */
3016 void
3017 sgen_ensure_free_space (size_t size)
3018 {
3019         int generation_to_collect = -1;
3020         const char *reason = NULL;
3021
3022         if (size > SGEN_MAX_SMALL_OBJ_SIZE) {
3023                 if (sgen_need_major_collection (size)) {
3024                         reason = "LOS overflow";
3025                         generation_to_collect = GENERATION_OLD;
3026                 }
3027         } else {
3028                 if (degraded_mode) {
3029                         if (sgen_need_major_collection (size)) {
3030                                 reason = "Degraded mode overflow";
3031                                 generation_to_collect = GENERATION_OLD;
3032                         }
3033                 } else if (sgen_need_major_collection (size)) {
3034                         reason = "Minor allowance";
3035                         generation_to_collect = GENERATION_OLD;
3036                 } else {
3037                         generation_to_collect = GENERATION_NURSERY;
3038                         reason = "Nursery full";
3039                 }
3040         }
3041
3042         if (generation_to_collect == -1) {
3043                 if (concurrent_collection_in_progress && sgen_workers_all_done ()) {
3044                         generation_to_collect = GENERATION_OLD;
3045                         reason = "Finish concurrent collection";
3046                 }
3047         }
3048
3049         if (generation_to_collect == -1)
3050                 return;
3051         sgen_perform_collection (size, generation_to_collect, reason, FALSE);
3052 }
3053
3054 /*
3055  * LOCKING: Assumes the GC lock is held.
3056  */
3057 void
3058 sgen_perform_collection (size_t requested_size, int generation_to_collect, const char *reason, gboolean wait_to_finish)
3059 {
3060         TV_DECLARE (gc_start);
3061         TV_DECLARE (gc_end);
3062         TV_DECLARE (gc_total_start);
3063         TV_DECLARE (gc_total_end);
3064         GGTimingInfo infos [2];
3065         int overflow_generation_to_collect = -1;
3066         int oldest_generation_collected = generation_to_collect;
3067         const char *overflow_reason = NULL;
3068
3069         MONO_GC_REQUESTED (generation_to_collect, requested_size, wait_to_finish ? 1 : 0);
3070         if (wait_to_finish)
3071                 binary_protocol_collection_force (generation_to_collect);
3072
3073         SGEN_ASSERT (0, generation_to_collect == GENERATION_NURSERY || generation_to_collect == GENERATION_OLD, "What generation is this?");
3074
3075         mono_profiler_gc_event (MONO_GC_EVENT_START, generation_to_collect);
3076
3077         TV_GETTIME (gc_start);
3078
3079         sgen_stop_world (generation_to_collect);
3080
3081         TV_GETTIME (gc_total_start);
3082
3083         if (concurrent_collection_in_progress) {
3084                 /*
3085                  * We update the concurrent collection.  If it finished, we're done.  If
3086                  * not, and we've been asked to do a nursery collection, we do that.
3087                  */
3088                 gboolean finish = major_should_finish_concurrent_collection () || (wait_to_finish && generation_to_collect == GENERATION_OLD);
3089
3090                 if (finish) {
3091                         major_finish_concurrent_collection (wait_to_finish);
3092                         oldest_generation_collected = GENERATION_OLD;
3093                 } else {
3094                         sgen_workers_signal_start_nursery_collection_and_wait ();
3095
3096                         major_update_concurrent_collection ();
3097                         if (generation_to_collect == GENERATION_NURSERY)
3098                                 collect_nursery (NULL, FALSE);
3099
3100                         sgen_workers_signal_finish_nursery_collection ();
3101                 }
3102
3103                 goto done;
3104         }
3105
3106         /*
3107          * If we've been asked to do a major collection, and the major collector wants to
3108          * run synchronously (to evacuate), we set the flag to do that.
3109          */
3110         if (generation_to_collect == GENERATION_OLD &&
3111                         allow_synchronous_major &&
3112                         major_collector.want_synchronous_collection &&
3113                         *major_collector.want_synchronous_collection) {
3114                 wait_to_finish = TRUE;
3115         }
3116
3117         SGEN_ASSERT (0, !concurrent_collection_in_progress, "Why did this not get handled above?");
3118
3119         /*
3120          * There's no concurrent collection in progress.  Collect the generation we're asked
3121          * to collect.  If the major collector is concurrent and we're not forced to wait,
3122          * start a concurrent collection.
3123          */
3124         // FIXME: extract overflow reason
3125         if (generation_to_collect == GENERATION_NURSERY) {
3126                 if (collect_nursery (NULL, FALSE)) {
3127                         overflow_generation_to_collect = GENERATION_OLD;
3128                         overflow_reason = "Minor overflow";
3129                 }
3130         } else {
3131                 if (major_collector.is_concurrent && !wait_to_finish) {
3132                         collect_nursery (NULL, FALSE);
3133                         major_start_concurrent_collection (reason);
3134                         // FIXME: set infos[0] properly
3135                         goto done;
3136                 }
3137
3138                 if (major_do_collection (reason, wait_to_finish)) {
3139                         overflow_generation_to_collect = GENERATION_NURSERY;
3140                         overflow_reason = "Excessive pinning";
3141                 }
3142         }
3143
3144         TV_GETTIME (gc_end);
3145
3146         memset (infos, 0, sizeof (infos));
3147         infos [0].generation = generation_to_collect;
3148         infos [0].reason = reason;
3149         infos [0].is_overflow = FALSE;
3150         infos [1].generation = -1;
3151         infos [0].total_time = SGEN_TV_ELAPSED (gc_start, gc_end);
3152
3153         SGEN_ASSERT (0, !concurrent_collection_in_progress, "Why did this not get handled above?");
3154
3155         if (overflow_generation_to_collect != -1) {
3156                 /*
3157                  * We need to do an overflow collection, either because we ran out of memory
3158                  * or the nursery is fully pinned.
3159                  */
3160
3161                 mono_profiler_gc_event (MONO_GC_EVENT_START, overflow_generation_to_collect);
3162                 infos [1].generation = overflow_generation_to_collect;
3163                 infos [1].reason = overflow_reason;
3164                 infos [1].is_overflow = TRUE;
3165                 infos [1].total_time = gc_end;
3166
3167                 if (overflow_generation_to_collect == GENERATION_NURSERY)
3168                         collect_nursery (NULL, FALSE);
3169                 else
3170                         major_do_collection (overflow_reason, wait_to_finish);
3171
3172                 TV_GETTIME (gc_end);
3173                 infos [1].total_time = SGEN_TV_ELAPSED (infos [1].total_time, gc_end);
3174
3175                 /* keep events symmetric */
3176                 mono_profiler_gc_event (MONO_GC_EVENT_END, overflow_generation_to_collect);
3177
3178                 oldest_generation_collected = MAX (oldest_generation_collected, overflow_generation_to_collect);
3179         }
3180
3181         SGEN_LOG (2, "Heap size: %lu, LOS size: %lu", (unsigned long)mono_gc_get_heap_size (), (unsigned long)los_memory_usage);
3182
3183         /* this also sets the proper pointers for the next allocation */
3184         if (generation_to_collect == GENERATION_NURSERY && !sgen_can_alloc_size (requested_size)) {
3185                 /* TypeBuilder and MonoMethod are killing mcs with fragmentation */
3186                 SGEN_LOG (1, "nursery collection didn't find enough room for %zd alloc (%zd pinned)", requested_size, sgen_get_pinned_count ());
3187                 sgen_dump_pin_queue ();
3188                 degraded_mode = 1;
3189         }
3190
3191  done:
3192         g_assert (sgen_gray_object_queue_is_empty (&gray_queue));
3193
3194         TV_GETTIME (gc_total_end);
3195         time_max = MAX (time_max, TV_ELAPSED (gc_total_start, gc_total_end));
3196
3197         sgen_restart_world (oldest_generation_collected, infos);
3198
3199         mono_profiler_gc_event (MONO_GC_EVENT_END, generation_to_collect);
3200 }
3201
3202 /*
3203  * ######################################################################
3204  * ########  Memory allocation from the OS
3205  * ######################################################################
3206  * This section of code deals with getting memory from the OS and
3207  * allocating memory for GC-internal data structures.
3208  * Internal memory can be handled with a freelist for small objects.
3209  */
3210
3211 /*
3212  * Debug reporting.
3213  */
3214 G_GNUC_UNUSED static void
3215 report_internal_mem_usage (void)
3216 {
3217         printf ("Internal memory usage:\n");
3218         sgen_report_internal_mem_usage ();
3219         printf ("Pinned memory usage:\n");
3220         major_collector.report_pinned_memory_usage ();
3221 }
3222
3223 /*
3224  * ######################################################################
3225  * ########  Finalization support
3226  * ######################################################################
3227  */
3228
3229 static inline gboolean
3230 sgen_major_is_object_alive (void *object)
3231 {
3232         mword objsize;
3233
3234         /* Oldgen objects can be pinned and forwarded too */
3235         if (SGEN_OBJECT_IS_PINNED (object) || SGEN_OBJECT_IS_FORWARDED (object))
3236                 return TRUE;
3237
3238         /*
3239          * FIXME: major_collector.is_object_live() also calculates the
3240          * size.  Avoid the double calculation.
3241          */
3242         objsize = SGEN_ALIGN_UP (sgen_safe_object_get_size ((MonoObject*)object));
3243         if (objsize > SGEN_MAX_SMALL_OBJ_SIZE)
3244                 return sgen_los_object_is_pinned (object);
3245
3246         return major_collector.is_object_live (object);
3247 }
3248
3249 /*
3250  * If the object has been forwarded it means it's still referenced from a root.
3251  * If it is pinned it's still alive as well.
3252  * A LOS object is only alive if we have pinned it.
3253  * Return TRUE if @obj is ready to be finalized.
3254  */
3255 static inline gboolean
3256 sgen_is_object_alive (void *object)
3257 {
3258         if (ptr_in_nursery (object))
3259                 return sgen_nursery_is_object_alive (object);
3260
3261         return sgen_major_is_object_alive (object);
3262 }
3263
3264 /*
3265  * This function returns true if @object is either alive or it belongs to the old gen
3266  * and we're currently doing a minor collection.
3267  */
3268 static inline int
3269 sgen_is_object_alive_for_current_gen (char *object)
3270 {
3271         if (ptr_in_nursery (object))
3272                 return sgen_nursery_is_object_alive (object);
3273
3274         if (current_collection_generation == GENERATION_NURSERY)
3275                 return TRUE;
3276
3277         return sgen_major_is_object_alive (object);
3278 }
3279
3280 /*
3281  * This function returns true if @object is either alive and belongs to the
3282  * current collection - major collections are full heap, so old gen objects
3283  * are never alive during a minor collection.
3284  */
3285 static inline int
3286 sgen_is_object_alive_and_on_current_collection (char *object)
3287 {
3288         if (ptr_in_nursery (object))
3289                 return sgen_nursery_is_object_alive (object);
3290
3291         if (current_collection_generation == GENERATION_NURSERY)
3292                 return FALSE;
3293
3294         return sgen_major_is_object_alive (object);
3295 }
3296
3297
3298 gboolean
3299 sgen_gc_is_object_ready_for_finalization (void *object)
3300 {
3301         return !sgen_is_object_alive (object);
3302 }
3303
3304 static gboolean
3305 has_critical_finalizer (MonoObject *obj)
3306 {
3307         MonoClass *class;
3308
3309         if (!mono_defaults.critical_finalizer_object)
3310                 return FALSE;
3311
3312         class = ((MonoVTable*)LOAD_VTABLE (obj))->klass;
3313
3314         return mono_class_has_parent_fast (class, mono_defaults.critical_finalizer_object);
3315 }
3316
3317 static gboolean
3318 is_finalization_aware (MonoObject *obj)
3319 {
3320         MonoVTable *vt = ((MonoVTable*)LOAD_VTABLE (obj));
3321         return (vt->gc_bits & SGEN_GC_BIT_FINALIZER_AWARE) == SGEN_GC_BIT_FINALIZER_AWARE;
3322 }
3323
3324 void
3325 sgen_queue_finalization_entry (MonoObject *obj)
3326 {
3327         FinalizeReadyEntry *entry = sgen_alloc_internal (INTERNAL_MEM_FINALIZE_READY_ENTRY);
3328         gboolean critical = has_critical_finalizer (obj);
3329         entry->object = obj;
3330         if (critical) {
3331                 entry->next = critical_fin_list;
3332                 critical_fin_list = entry;
3333         } else {
3334                 entry->next = fin_ready_list;
3335                 fin_ready_list = entry;
3336         }
3337
3338         if (fin_callbacks.object_queued_for_finalization && is_finalization_aware (obj))
3339                 fin_callbacks.object_queued_for_finalization (obj);
3340
3341 #ifdef ENABLE_DTRACE
3342         if (G_UNLIKELY (MONO_GC_FINALIZE_ENQUEUE_ENABLED ())) {
3343                 int gen = sgen_ptr_in_nursery (obj) ? GENERATION_NURSERY : GENERATION_OLD;
3344                 MonoVTable *vt = (MonoVTable*)LOAD_VTABLE (obj);
3345                 MONO_GC_FINALIZE_ENQUEUE ((mword)obj, sgen_safe_object_get_size (obj),
3346                                 vt->klass->name_space, vt->klass->name, gen, critical);
3347         }
3348 #endif
3349 }
3350
3351 gboolean
3352 sgen_object_is_live (void *obj)
3353 {
3354         return sgen_is_object_alive_and_on_current_collection (obj);
3355 }
3356
3357 /* LOCKING: requires that the GC lock is held */
3358 static void
3359 null_ephemerons_for_domain (MonoDomain *domain)
3360 {
3361         EphemeronLinkNode *current = ephemeron_list, *prev = NULL;
3362
3363         while (current) {
3364                 MonoObject *object = (MonoObject*)current->array;
3365
3366                 if (object)
3367                         SGEN_ASSERT (0, object->vtable, "Can't have objects without vtables.");
3368
3369                 if (object && object->vtable->domain == domain) {
3370                         EphemeronLinkNode *tmp = current;
3371
3372                         if (prev)
3373                                 prev->next = current->next;
3374                         else
3375                                 ephemeron_list = current->next;
3376
3377                         current = current->next;
3378                         sgen_free_internal (tmp, INTERNAL_MEM_EPHEMERON_LINK);
3379                 } else {
3380                         prev = current;
3381                         current = current->next;
3382                 }
3383         }
3384 }
3385
3386 /* LOCKING: requires that the GC lock is held */
3387 static void
3388 clear_unreachable_ephemerons (ScanCopyContext ctx)
3389 {
3390         CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object;
3391         GrayQueue *queue = ctx.queue;
3392         EphemeronLinkNode *current = ephemeron_list, *prev = NULL;
3393         MonoArray *array;
3394         Ephemeron *cur, *array_end;
3395         char *tombstone;
3396
3397         while (current) {
3398                 char *object = current->array;
3399
3400                 if (!sgen_is_object_alive_for_current_gen (object)) {
3401                         EphemeronLinkNode *tmp = current;
3402
3403                         SGEN_LOG (5, "Dead Ephemeron array at %p", object);
3404
3405                         if (prev)
3406                                 prev->next = current->next;
3407                         else
3408                                 ephemeron_list = current->next;
3409
3410                         current = current->next;
3411                         sgen_free_internal (tmp, INTERNAL_MEM_EPHEMERON_LINK);
3412
3413                         continue;
3414                 }
3415
3416                 copy_func ((void**)&object, queue);
3417                 current->array = object;
3418
3419                 SGEN_LOG (5, "Clearing unreachable entries for ephemeron array at %p", object);
3420
3421                 array = (MonoArray*)object;
3422                 cur = mono_array_addr (array, Ephemeron, 0);
3423                 array_end = cur + mono_array_length_fast (array);
3424                 tombstone = (char*)((MonoVTable*)LOAD_VTABLE (object))->domain->ephemeron_tombstone;
3425
3426                 for (; cur < array_end; ++cur) {
3427                         char *key = (char*)cur->key;
3428
3429                         if (!key || key == tombstone)
3430                                 continue;
3431
3432                         SGEN_LOG (5, "[%td] key %p (%s) value %p (%s)", cur - mono_array_addr (array, Ephemeron, 0),
3433                                 key, sgen_is_object_alive_for_current_gen (key) ? "reachable" : "unreachable",
3434                                 cur->value, cur->value && sgen_is_object_alive_for_current_gen (cur->value) ? "reachable" : "unreachable");
3435
3436                         if (!sgen_is_object_alive_for_current_gen (key)) {
3437                                 cur->key = tombstone;
3438                                 cur->value = NULL;
3439                                 continue;
3440                         }
3441                 }
3442                 prev = current;
3443                 current = current->next;
3444         }
3445 }
3446
3447 /*
3448 LOCKING: requires that the GC lock is held
3449
3450 Limitations: We scan all ephemerons on every collection since the current design doesn't allow for a simple nursery/mature split.
3451 */
3452 static int
3453 mark_ephemerons_in_range (ScanCopyContext ctx)
3454 {
3455         CopyOrMarkObjectFunc copy_func = ctx.ops->copy_or_mark_object;
3456         GrayQueue *queue = ctx.queue;
3457         int nothing_marked = 1;
3458         EphemeronLinkNode *current = ephemeron_list;
3459         MonoArray *array;
3460         Ephemeron *cur, *array_end;
3461         char *tombstone;
3462
3463         for (current = ephemeron_list; current; current = current->next) {
3464                 char *object = current->array;
3465                 SGEN_LOG (5, "Ephemeron array at %p", object);
3466
3467                 /*It has to be alive*/
3468                 if (!sgen_is_object_alive_for_current_gen (object)) {
3469                         SGEN_LOG (5, "\tnot reachable");
3470                         continue;
3471                 }
3472
3473                 copy_func ((void**)&object, queue);
3474
3475                 array = (MonoArray*)object;
3476                 cur = mono_array_addr (array, Ephemeron, 0);
3477                 array_end = cur + mono_array_length_fast (array);
3478                 tombstone = (char*)((MonoVTable*)LOAD_VTABLE (object))->domain->ephemeron_tombstone;
3479
3480                 for (; cur < array_end; ++cur) {
3481                         char *key = cur->key;
3482
3483                         if (!key || key == tombstone)
3484                                 continue;
3485
3486                         SGEN_LOG (5, "[%td] key %p (%s) value %p (%s)", cur - mono_array_addr (array, Ephemeron, 0),
3487                                 key, sgen_is_object_alive_for_current_gen (key) ? "reachable" : "unreachable",
3488                                 cur->value, cur->value && sgen_is_object_alive_for_current_gen (cur->value) ? "reachable" : "unreachable");
3489
3490                         if (sgen_is_object_alive_for_current_gen (key)) {
3491                                 char *value = cur->value;
3492
3493                                 copy_func ((void**)&cur->key, queue);
3494                                 if (value) {
3495                                         if (!sgen_is_object_alive_for_current_gen (value))
3496                                                 nothing_marked = 0;
3497                                         copy_func ((void**)&cur->value, queue);
3498                                 }
3499                         }
3500                 }
3501         }
3502
3503         SGEN_LOG (5, "Ephemeron run finished. Is it done %d", nothing_marked);
3504         return nothing_marked;
3505 }
3506
3507 int
3508 mono_gc_invoke_finalizers (void)
3509 {
3510         FinalizeReadyEntry *entry = NULL;
3511         gboolean entry_is_critical = FALSE;
3512         int count = 0;
3513         void *obj;
3514         /* FIXME: batch to reduce lock contention */
3515         while (fin_ready_list || critical_fin_list) {
3516                 LOCK_GC;
3517
3518                 if (entry) {
3519                         FinalizeReadyEntry **list = entry_is_critical ? &critical_fin_list : &fin_ready_list;
3520
3521                         /* We have finalized entry in the last
3522                            interation, now we need to remove it from
3523                            the list. */
3524                         if (*list == entry)
3525                                 *list = entry->next;
3526                         else {
3527                                 FinalizeReadyEntry *e = *list;
3528                                 while (e->next != entry)
3529                                         e = e->next;
3530                                 e->next = entry->next;
3531                         }
3532                         sgen_free_internal (entry, INTERNAL_MEM_FINALIZE_READY_ENTRY);
3533                         entry = NULL;
3534                 }
3535
3536                 /* Now look for the first non-null entry. */
3537                 for (entry = fin_ready_list; entry && !entry->object; entry = entry->next)
3538                         ;
3539                 if (entry) {
3540                         entry_is_critical = FALSE;
3541                 } else {
3542                         entry_is_critical = TRUE;
3543                         for (entry = critical_fin_list; entry && !entry->object; entry = entry->next)
3544                                 ;
3545                 }
3546
3547                 if (entry) {
3548                         g_assert (entry->object);
3549                         num_ready_finalizers--;
3550                         obj = entry->object;
3551                         entry->object = NULL;
3552                         SGEN_LOG (7, "Finalizing object %p (%s)", obj, safe_name (obj));
3553                 }
3554
3555                 UNLOCK_GC;
3556
3557                 if (!entry)
3558                         break;
3559
3560                 g_assert (entry->object == NULL);
3561                 count++;
3562                 /* the object is on the stack so it is pinned */
3563                 /*g_print ("Calling finalizer for object: %p (%s)\n", entry->object, safe_name (entry->object));*/
3564                 mono_gc_run_finalize (obj, NULL);
3565         }
3566         g_assert (!entry);
3567         return count;
3568 }
3569
3570 gboolean
3571 mono_gc_pending_finalizers (void)
3572 {
3573         return fin_ready_list || critical_fin_list;
3574 }
3575
3576 /*
3577  * ######################################################################
3578  * ########  registered roots support
3579  * ######################################################################
3580  */
3581
3582 /*
3583  * We do not coalesce roots.
3584  */
3585 static int
3586 mono_gc_register_root_inner (char *start, size_t size, void *descr, int root_type)
3587 {
3588         RootRecord new_root;
3589         int i;
3590         LOCK_GC;
3591         for (i = 0; i < ROOT_TYPE_NUM; ++i) {
3592                 RootRecord *root = sgen_hash_table_lookup (&roots_hash [i], start);
3593                 /* we allow changing the size and the descriptor (for thread statics etc) */
3594                 if (root) {
3595                         size_t old_size = root->end_root - start;
3596                         root->end_root = start + size;
3597                         g_assert (((root->root_desc != 0) && (descr != NULL)) ||
3598                                           ((root->root_desc == 0) && (descr == NULL)));
3599                         root->root_desc = (mword)descr;
3600                         roots_size += size;
3601                         roots_size -= old_size;
3602                         UNLOCK_GC;
3603                         return TRUE;
3604                 }
3605         }
3606
3607         new_root.end_root = start + size;
3608         new_root.root_desc = (mword)descr;
3609
3610         sgen_hash_table_replace (&roots_hash [root_type], start, &new_root, NULL);
3611         roots_size += size;
3612
3613         SGEN_LOG (3, "Added root for range: %p-%p, descr: %p  (%d/%d bytes)", start, new_root.end_root, descr, (int)size, (int)roots_size);
3614
3615         UNLOCK_GC;
3616         return TRUE;
3617 }
3618
3619 int
3620 mono_gc_register_root (char *start, size_t size, void *descr)
3621 {
3622         return mono_gc_register_root_inner (start, size, descr, descr ? ROOT_TYPE_NORMAL : ROOT_TYPE_PINNED);
3623 }
3624
3625 int
3626 mono_gc_register_root_wbarrier (char *start, size_t size, void *descr)
3627 {
3628         return mono_gc_register_root_inner (start, size, descr, ROOT_TYPE_WBARRIER);
3629 }
3630
3631 void
3632 mono_gc_deregister_root (char* addr)
3633 {
3634         int root_type;
3635         RootRecord root;
3636
3637         LOCK_GC;
3638         for (root_type = 0; root_type < ROOT_TYPE_NUM; ++root_type) {
3639                 if (sgen_hash_table_remove (&roots_hash [root_type], addr, &root))
3640                         roots_size -= (root.end_root - addr);
3641         }
3642         UNLOCK_GC;
3643 }
3644
3645 /*
3646  * ######################################################################
3647  * ########  Thread handling (stop/start code)
3648  * ######################################################################
3649  */
3650
3651 unsigned int sgen_global_stop_count = 0;
3652
3653 int
3654 sgen_get_current_collection_generation (void)
3655 {
3656         return current_collection_generation;
3657 }
3658
3659 void
3660 mono_gc_set_gc_callbacks (MonoGCCallbacks *callbacks)
3661 {
3662         gc_callbacks = *callbacks;
3663 }
3664
3665 MonoGCCallbacks *
3666 mono_gc_get_gc_callbacks ()
3667 {
3668         return &gc_callbacks;
3669 }
3670
3671 /* Variables holding start/end nursery so it won't have to be passed at every call */
3672 static void *scan_area_arg_start, *scan_area_arg_end;
3673
3674 void
3675 mono_gc_conservatively_scan_area (void *start, void *end)
3676 {
3677         conservatively_pin_objects_from (start, end, scan_area_arg_start, scan_area_arg_end, PIN_TYPE_STACK);
3678 }
3679
3680 void*
3681 mono_gc_scan_object (void *obj, void *gc_data)
3682 {
3683         ScanCopyContext *ctx = gc_data;
3684         ctx->ops->copy_or_mark_object (&obj, ctx->queue);
3685         return obj;
3686 }
3687
3688 /*
3689  * Mark from thread stacks and registers.
3690  */
3691 static void
3692 scan_thread_data (void *start_nursery, void *end_nursery, gboolean precise, ScanCopyContext ctx)
3693 {
3694         SgenThreadInfo *info;
3695
3696         scan_area_arg_start = start_nursery;
3697         scan_area_arg_end = end_nursery;
3698
3699         FOREACH_THREAD (info) {
3700                 if (info->skip) {
3701                         SGEN_LOG (3, "Skipping dead thread %p, range: %p-%p, size: %td", info, info->stack_start, info->stack_end, (char*)info->stack_end - (char*)info->stack_start);
3702                         continue;
3703                 }
3704                 if (info->gc_disabled) {
3705                         SGEN_LOG (3, "GC disabled for thread %p, range: %p-%p, size: %td", info, info->stack_start, info->stack_end, (char*)info->stack_end - (char*)info->stack_start);
3706                         continue;
3707                 }
3708                 if (!mono_thread_info_is_live (info)) {
3709                         SGEN_LOG (3, "Skipping non-running thread %p, range: %p-%p, size: %td (state %x)", info, info->stack_start, info->stack_end, (char*)info->stack_end - (char*)info->stack_start, info->info.thread_state);
3710                         continue;
3711                 }
3712                 g_assert (info->suspend_done);
3713                 SGEN_LOG (3, "Scanning thread %p, range: %p-%p, size: %td, pinned=%zd", info, info->stack_start, info->stack_end, (char*)info->stack_end - (char*)info->stack_start, sgen_get_pinned_count ());
3714                 if (gc_callbacks.thread_mark_func && !conservative_stack_mark) {
3715                         gc_callbacks.thread_mark_func (info->runtime_data, info->stack_start, info->stack_end, precise, &ctx);
3716                 } else if (!precise) {
3717                         if (!conservative_stack_mark) {
3718                                 fprintf (stderr, "Precise stack mark not supported - disabling.\n");
3719                                 conservative_stack_mark = TRUE;
3720                         }
3721                         conservatively_pin_objects_from (info->stack_start, info->stack_end, start_nursery, end_nursery, PIN_TYPE_STACK);
3722                 }
3723
3724                 if (!precise) {
3725 #ifdef USE_MONO_CTX
3726                         conservatively_pin_objects_from ((void**)&info->ctx, (void**)&info->ctx + ARCH_NUM_REGS,
3727                                 start_nursery, end_nursery, PIN_TYPE_STACK);
3728 #else
3729                         conservatively_pin_objects_from ((void**)&info->regs, (void**)&info->regs + ARCH_NUM_REGS,
3730                                         start_nursery, end_nursery, PIN_TYPE_STACK);
3731 #endif
3732                 }
3733         } END_FOREACH_THREAD
3734 }
3735
3736 static gboolean
3737 ptr_on_stack (void *ptr)
3738 {
3739         gpointer stack_start = &stack_start;
3740         SgenThreadInfo *info = mono_thread_info_current ();
3741
3742         if (ptr >= stack_start && ptr < (gpointer)info->stack_end)
3743                 return TRUE;
3744         return FALSE;
3745 }
3746
3747 static void*
3748 sgen_thread_register (SgenThreadInfo* info, void *addr)
3749 {
3750         size_t stsize = 0;
3751         guint8 *staddr = NULL;
3752
3753 #ifndef HAVE_KW_THREAD
3754         info->tlab_start = info->tlab_next = info->tlab_temp_end = info->tlab_real_end = NULL;
3755
3756         g_assert (!mono_native_tls_get_value (thread_info_key));
3757         mono_native_tls_set_value (thread_info_key, info);
3758 #else
3759         sgen_thread_info = info;
3760 #endif
3761
3762 #ifdef SGEN_POSIX_STW
3763         info->stop_count = -1;
3764         info->signal = 0;
3765 #endif
3766         info->skip = 0;
3767         info->stack_start = NULL;
3768         info->stopped_ip = NULL;
3769         info->stopped_domain = NULL;
3770 #ifdef USE_MONO_CTX
3771         memset (&info->ctx, 0, sizeof (MonoContext));
3772 #else
3773         memset (&info->regs, 0, sizeof (info->regs));
3774 #endif
3775
3776         sgen_init_tlab_info (info);
3777
3778         binary_protocol_thread_register ((gpointer)mono_thread_info_get_tid (info));
3779
3780         /* On win32, stack_start_limit should be 0, since the stack can grow dynamically */
3781         mono_thread_info_get_stack_bounds (&staddr, &stsize);
3782         if (staddr) {
3783 #ifndef HOST_WIN32
3784                 info->stack_start_limit = staddr;
3785 #endif
3786                 info->stack_end = staddr + stsize;
3787         } else {
3788                 gsize stack_bottom = (gsize)addr;
3789                 stack_bottom += 4095;
3790                 stack_bottom &= ~4095;
3791                 info->stack_end = (char*)stack_bottom;
3792         }
3793
3794 #ifdef HAVE_KW_THREAD
3795         stack_end = info->stack_end;
3796 #endif
3797
3798         SGEN_LOG (3, "registered thread %p (%p) stack end %p", info, (gpointer)mono_thread_info_get_tid (info), info->stack_end);
3799
3800         if (gc_callbacks.thread_attach_func)
3801                 info->runtime_data = gc_callbacks.thread_attach_func ();
3802         return info;
3803 }
3804
3805 static void
3806 sgen_thread_detach (SgenThreadInfo *p)
3807 {
3808         /* If a delegate is passed to native code and invoked on a thread we dont
3809          * know about, the jit will register it with mono_jit_thread_attach, but
3810          * we have no way of knowing when that thread goes away.  SGen has a TSD
3811          * so we assume that if the domain is still registered, we can detach
3812          * the thread
3813          */
3814         if (mono_domain_get ())
3815                 mono_thread_detach_internal (mono_thread_internal_current ());
3816 }
3817
3818 static void
3819 sgen_thread_unregister (SgenThreadInfo *p)
3820 {
3821         MonoNativeThreadId tid;
3822
3823         tid = mono_thread_info_get_tid (p);
3824         binary_protocol_thread_unregister ((gpointer)tid);
3825         SGEN_LOG (3, "unregister thread %p (%p)", p, (gpointer)tid);
3826
3827 #ifndef HAVE_KW_THREAD
3828         mono_native_tls_set_value (thread_info_key, NULL);
3829 #else
3830         sgen_thread_info = NULL;
3831 #endif
3832
3833         if (p->info.runtime_thread)
3834                 mono_threads_add_joinable_thread ((gpointer)tid);
3835
3836         if (gc_callbacks.thread_detach_func) {
3837                 gc_callbacks.thread_detach_func (p->runtime_data);
3838                 p->runtime_data = NULL;
3839         }
3840 }
3841
3842
3843 static void
3844 sgen_thread_attach (SgenThreadInfo *info)
3845 {
3846         LOCK_GC;
3847         /*this is odd, can we get attached before the gc is inited?*/
3848         init_stats ();
3849         UNLOCK_GC;
3850
3851         if (gc_callbacks.thread_attach_func && !info->runtime_data)
3852                 info->runtime_data = gc_callbacks.thread_attach_func ();
3853 }
3854 gboolean
3855 mono_gc_register_thread (void *baseptr)
3856 {
3857         return mono_thread_info_attach (baseptr) != NULL;
3858 }
3859
3860 /*
3861  * mono_gc_set_stack_end:
3862  *
3863  *   Set the end of the current threads stack to STACK_END. The stack space between
3864  * STACK_END and the real end of the threads stack will not be scanned during collections.
3865  */
3866 void
3867 mono_gc_set_stack_end (void *stack_end)
3868 {
3869         SgenThreadInfo *info;
3870
3871         LOCK_GC;
3872         info = mono_thread_info_current ();
3873         if (info) {
3874                 g_assert (stack_end < info->stack_end);
3875                 info->stack_end = stack_end;
3876         }
3877         UNLOCK_GC;
3878 }
3879
3880 #if USE_PTHREAD_INTERCEPT
3881
3882
3883 int
3884 mono_gc_pthread_create (pthread_t *new_thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
3885 {
3886         return pthread_create (new_thread, attr, start_routine, arg);
3887 }
3888
3889 int
3890 mono_gc_pthread_join (pthread_t thread, void **retval)
3891 {
3892         return pthread_join (thread, retval);
3893 }
3894
3895 int
3896 mono_gc_pthread_detach (pthread_t thread)
3897 {
3898         return pthread_detach (thread);
3899 }
3900
3901 void
3902 mono_gc_pthread_exit (void *retval)
3903 {
3904         mono_thread_info_detach ();
3905         pthread_exit (retval);
3906         g_assert_not_reached ();
3907 }
3908
3909 #endif /* USE_PTHREAD_INTERCEPT */
3910
3911 /*
3912  * ######################################################################
3913  * ########  Write barriers
3914  * ######################################################################
3915  */
3916
3917 /*
3918  * Note: the write barriers first do the needed GC work and then do the actual store:
3919  * this way the value is visible to the conservative GC scan after the write barrier
3920  * itself. If a GC interrupts the barrier in the middle, value will be kept alive by
3921  * the conservative scan, otherwise by the remembered set scan.
3922  */
3923 void
3924 mono_gc_wbarrier_set_field (MonoObject *obj, gpointer field_ptr, MonoObject* value)
3925 {
3926         HEAVY_STAT (++stat_wbarrier_set_field);
3927         if (ptr_in_nursery (field_ptr)) {
3928                 *(void**)field_ptr = value;
3929                 return;
3930         }
3931         SGEN_LOG (8, "Adding remset at %p", field_ptr);
3932         if (value)
3933                 binary_protocol_wbarrier (field_ptr, value, value->vtable);
3934
3935         remset.wbarrier_set_field (obj, field_ptr, value);
3936 }
3937
3938 void
3939 mono_gc_wbarrier_set_arrayref (MonoArray *arr, gpointer slot_ptr, MonoObject* value)
3940 {
3941         HEAVY_STAT (++stat_wbarrier_set_arrayref);
3942         if (ptr_in_nursery (slot_ptr)) {
3943                 *(void**)slot_ptr = value;
3944                 return;
3945         }
3946         SGEN_LOG (8, "Adding remset at %p", slot_ptr);
3947         if (value)
3948                 binary_protocol_wbarrier (slot_ptr, value, value->vtable);
3949
3950         remset.wbarrier_set_arrayref (arr, slot_ptr, value);
3951 }
3952
3953 void
3954 mono_gc_wbarrier_arrayref_copy (gpointer dest_ptr, gpointer src_ptr, int count)
3955 {
3956         HEAVY_STAT (++stat_wbarrier_arrayref_copy);
3957         /*This check can be done without taking a lock since dest_ptr array is pinned*/
3958         if (ptr_in_nursery (dest_ptr) || count <= 0) {
3959                 mono_gc_memmove_aligned (dest_ptr, src_ptr, count * sizeof (gpointer));
3960                 return;
3961         }
3962
3963 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
3964         if (binary_protocol_is_heavy_enabled ()) {
3965                 int i;
3966                 for (i = 0; i < count; ++i) {
3967                         gpointer dest = (gpointer*)dest_ptr + i;
3968                         gpointer obj = *((gpointer*)src_ptr + i);
3969                         if (obj)
3970                                 binary_protocol_wbarrier (dest, obj, (gpointer)LOAD_VTABLE (obj));
3971                 }
3972         }
3973 #endif
3974
3975         remset.wbarrier_arrayref_copy (dest_ptr, src_ptr, count);
3976 }
3977
3978 void
3979 mono_gc_wbarrier_generic_nostore (gpointer ptr)
3980 {
3981         gpointer obj;
3982
3983         HEAVY_STAT (++stat_wbarrier_generic_store);
3984
3985 #ifdef XDOMAIN_CHECKS_IN_WBARRIER
3986         /* FIXME: ptr_in_heap must be called with the GC lock held */
3987         if (xdomain_checks && *(MonoObject**)ptr && ptr_in_heap (ptr)) {
3988                 char *start = sgen_find_object_for_ptr (ptr);
3989                 MonoObject *value = *(MonoObject**)ptr;
3990                 LOCK_GC;
3991                 g_assert (start);
3992                 if (start) {
3993                         MonoObject *obj = (MonoObject*)start;
3994                         if (obj->vtable->domain != value->vtable->domain)
3995                                 g_assert (is_xdomain_ref_allowed (ptr, start, obj->vtable->domain));
3996                 }
3997                 UNLOCK_GC;
3998         }
3999 #endif
4000
4001         obj = *(gpointer*)ptr;
4002         if (obj)
4003                 binary_protocol_wbarrier (ptr, obj, (gpointer)LOAD_VTABLE (obj));
4004
4005         if (ptr_in_nursery (ptr) || ptr_on_stack (ptr)) {
4006                 SGEN_LOG (8, "Skipping remset at %p", ptr);
4007                 return;
4008         }
4009
4010         /*
4011          * We need to record old->old pointer locations for the
4012          * concurrent collector.
4013          */
4014         if (!ptr_in_nursery (obj) && !concurrent_collection_in_progress) {
4015                 SGEN_LOG (8, "Skipping remset at %p", ptr);
4016                 return;
4017         }
4018
4019         SGEN_LOG (8, "Adding remset at %p", ptr);
4020
4021         remset.wbarrier_generic_nostore (ptr);
4022 }
4023
4024 void
4025 mono_gc_wbarrier_generic_store (gpointer ptr, MonoObject* value)
4026 {
4027         SGEN_LOG (8, "Wbarrier store at %p to %p (%s)", ptr, value, value ? safe_name (value) : "null");
4028         SGEN_UPDATE_REFERENCE_ALLOW_NULL (ptr, value);
4029         if (ptr_in_nursery (value))
4030                 mono_gc_wbarrier_generic_nostore (ptr);
4031         sgen_dummy_use (value);
4032 }
4033
4034 /* Same as mono_gc_wbarrier_generic_store () but performs the store
4035  * as an atomic operation with release semantics.
4036  */
4037 void
4038 mono_gc_wbarrier_generic_store_atomic (gpointer ptr, MonoObject *value)
4039 {
4040         HEAVY_STAT (++stat_wbarrier_generic_store_atomic);
4041
4042         SGEN_LOG (8, "Wbarrier atomic store at %p to %p (%s)", ptr, value, value ? safe_name (value) : "null");
4043
4044         InterlockedWritePointer (ptr, value);
4045
4046         if (ptr_in_nursery (value))
4047                 mono_gc_wbarrier_generic_nostore (ptr);
4048
4049         sgen_dummy_use (value);
4050 }
4051
4052 void mono_gc_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap)
4053 {
4054         mword *dest = _dest;
4055         mword *src = _src;
4056
4057         while (size) {
4058                 if (bitmap & 0x1)
4059                         mono_gc_wbarrier_generic_store (dest, (MonoObject*)*src);
4060                 else
4061                         SGEN_UPDATE_REFERENCE_ALLOW_NULL (dest, *src);
4062                 ++src;
4063                 ++dest;
4064                 size -= SIZEOF_VOID_P;
4065                 bitmap >>= 1;
4066         }
4067 }
4068
4069 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
4070 #undef HANDLE_PTR
4071 #define HANDLE_PTR(ptr,obj) do {                                        \
4072                 gpointer o = *(gpointer*)(ptr);                         \
4073                 if ((o)) {                                              \
4074                         gpointer d = ((char*)dest) + ((char*)(ptr) - (char*)(obj)); \
4075                         binary_protocol_wbarrier (d, o, (gpointer) LOAD_VTABLE (o)); \
4076                 }                                                       \
4077         } while (0)
4078
4079 static void
4080 scan_object_for_binary_protocol_copy_wbarrier (gpointer dest, char *start, mword desc)
4081 {
4082 #define SCAN_OBJECT_NOVTABLE
4083 #include "sgen-scan-object.h"
4084 }
4085 #endif
4086
4087 void
4088 mono_gc_wbarrier_value_copy (gpointer dest, gpointer src, int count, MonoClass *klass)
4089 {
4090         HEAVY_STAT (++stat_wbarrier_value_copy);
4091         g_assert (klass->valuetype);
4092
4093         SGEN_LOG (8, "Adding value remset at %p, count %d, descr %p for class %s (%p)", dest, count, klass->gc_descr, klass->name, klass);
4094
4095         if (ptr_in_nursery (dest) || ptr_on_stack (dest) || !SGEN_CLASS_HAS_REFERENCES (klass)) {
4096                 size_t element_size = mono_class_value_size (klass, NULL);
4097                 size_t size = count * element_size;
4098                 mono_gc_memmove_atomic (dest, src, size);
4099                 return;
4100         }
4101
4102 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
4103         if (binary_protocol_is_heavy_enabled ()) {
4104                 size_t element_size = mono_class_value_size (klass, NULL);
4105                 int i;
4106                 for (i = 0; i < count; ++i) {
4107                         scan_object_for_binary_protocol_copy_wbarrier ((char*)dest + i * element_size,
4108                                         (char*)src + i * element_size - sizeof (MonoObject),
4109                                         (mword) klass->gc_descr);
4110                 }
4111         }
4112 #endif
4113
4114         remset.wbarrier_value_copy (dest, src, count, klass);
4115 }
4116
4117 /**
4118  * mono_gc_wbarrier_object_copy:
4119  *
4120  * Write barrier to call when obj is the result of a clone or copy of an object.
4121  */
4122 void
4123 mono_gc_wbarrier_object_copy (MonoObject* obj, MonoObject *src)
4124 {
4125         int size;
4126
4127         HEAVY_STAT (++stat_wbarrier_object_copy);
4128
4129         if (ptr_in_nursery (obj) || ptr_on_stack (obj)) {
4130                 size = mono_object_class (obj)->instance_size;
4131                 mono_gc_memmove_aligned ((char*)obj + sizeof (MonoObject), (char*)src + sizeof (MonoObject),
4132                                 size - sizeof (MonoObject));
4133                 return;
4134         }
4135
4136 #ifdef SGEN_HEAVY_BINARY_PROTOCOL
4137         if (binary_protocol_is_heavy_enabled ())
4138                 scan_object_for_binary_protocol_copy_wbarrier (obj, (char*)src, (mword) src->vtable->gc_descr);
4139 #endif
4140
4141         remset.wbarrier_object_copy (obj, src);
4142 }
4143
4144
4145 /*
4146  * ######################################################################
4147  * ########  Other mono public interface functions.
4148  * ######################################################################
4149  */
4150
4151 #define REFS_SIZE 128
4152 typedef struct {
4153         void *data;
4154         MonoGCReferences callback;
4155         int flags;
4156         int count;
4157         int called;
4158         MonoObject *refs [REFS_SIZE];
4159         uintptr_t offsets [REFS_SIZE];
4160 } HeapWalkInfo;
4161
4162 #undef HANDLE_PTR
4163 #define HANDLE_PTR(ptr,obj)     do {    \
4164                 if (*(ptr)) {   \
4165                         if (hwi->count == REFS_SIZE) {  \
4166                                 hwi->callback ((MonoObject*)start, mono_object_class (start), hwi->called? 0: size, hwi->count, hwi->refs, hwi->offsets, hwi->data);    \
4167                                 hwi->count = 0; \
4168                                 hwi->called = 1;        \
4169                         }       \
4170                         hwi->offsets [hwi->count] = (char*)(ptr)-(char*)start;  \
4171                         hwi->refs [hwi->count++] = *(ptr);      \
4172                 }       \
4173         } while (0)
4174
4175 static void
4176 collect_references (HeapWalkInfo *hwi, char *start, size_t size)
4177 {
4178         mword desc = sgen_obj_get_descriptor (start);
4179
4180 #include "sgen-scan-object.h"
4181 }
4182
4183 static void
4184 walk_references (char *start, size_t size, void *data)
4185 {
4186         HeapWalkInfo *hwi = data;
4187         hwi->called = 0;
4188         hwi->count = 0;
4189         collect_references (hwi, start, size);
4190         if (hwi->count || !hwi->called)
4191                 hwi->callback ((MonoObject*)start, mono_object_class (start), hwi->called? 0: size, hwi->count, hwi->refs, hwi->offsets, hwi->data);
4192 }
4193
4194 /**
4195  * mono_gc_walk_heap:
4196  * @flags: flags for future use
4197  * @callback: a function pointer called for each object in the heap
4198  * @data: a user data pointer that is passed to callback
4199  *
4200  * This function can be used to iterate over all the live objects in the heap:
4201  * for each object, @callback is invoked, providing info about the object's
4202  * location in memory, its class, its size and the objects it references.
4203  * For each referenced object it's offset from the object address is
4204  * reported in the offsets array.
4205  * The object references may be buffered, so the callback may be invoked
4206  * multiple times for the same object: in all but the first call, the size
4207  * argument will be zero.
4208  * Note that this function can be only called in the #MONO_GC_EVENT_PRE_START_WORLD
4209  * profiler event handler.
4210  *
4211  * Returns: a non-zero value if the GC doesn't support heap walking
4212  */
4213 int
4214 mono_gc_walk_heap (int flags, MonoGCReferences callback, void *data)
4215 {
4216         HeapWalkInfo hwi;
4217
4218         hwi.flags = flags;
4219         hwi.callback = callback;
4220         hwi.data = data;
4221
4222         sgen_clear_nursery_fragments ();
4223         sgen_scan_area_with_callback (nursery_section->data, nursery_section->end_data, walk_references, &hwi, FALSE);
4224
4225         major_collector.iterate_objects (ITERATE_OBJECTS_SWEEP_ALL, walk_references, &hwi);
4226         sgen_los_iterate_objects (walk_references, &hwi);
4227
4228         return 0;
4229 }
4230
4231 void
4232 mono_gc_collect (int generation)
4233 {
4234         LOCK_GC;
4235         if (generation > 1)
4236                 generation = 1;
4237         sgen_perform_collection (0, generation, "user request", TRUE);
4238         UNLOCK_GC;
4239 }
4240
4241 int
4242 mono_gc_max_generation (void)
4243 {
4244         return 1;
4245 }
4246
4247 int
4248 mono_gc_collection_count (int generation)
4249 {
4250         if (generation == 0)
4251                 return gc_stats.minor_gc_count;
4252         return gc_stats.major_gc_count;
4253 }
4254
4255 int64_t
4256 mono_gc_get_used_size (void)
4257 {
4258         gint64 tot = 0;
4259         LOCK_GC;
4260         tot = los_memory_usage;
4261         tot += nursery_section->next_data - nursery_section->data;
4262         tot += major_collector.get_used_size ();
4263         /* FIXME: account for pinned objects */
4264         UNLOCK_GC;
4265         return tot;
4266 }
4267
4268 int
4269 mono_gc_get_los_limit (void)
4270 {
4271         return MAX_SMALL_OBJ_SIZE;
4272 }
4273
4274 void
4275 mono_gc_set_string_length (MonoString *str, gint32 new_length)
4276 {
4277         mono_unichar2 *new_end = str->chars + new_length;
4278
4279         /* zero the discarded string. This null-delimits the string and allows
4280          * the space to be reclaimed by SGen. */
4281
4282         if (nursery_canaries_enabled () && sgen_ptr_in_nursery (str)) {
4283                 CHECK_CANARY_FOR_OBJECT (str);
4284                 memset (new_end, 0, (str->length - new_length + 1) * sizeof (mono_unichar2) + CANARY_SIZE);
4285                 memcpy (new_end + 1 , CANARY_STRING, CANARY_SIZE);
4286         } else {
4287                 memset (new_end, 0, (str->length - new_length + 1) * sizeof (mono_unichar2));
4288         }
4289
4290         str->length = new_length;
4291 }
4292
4293 gboolean
4294 mono_gc_user_markers_supported (void)
4295 {
4296         return TRUE;
4297 }
4298
4299 gboolean
4300 mono_object_is_alive (MonoObject* o)
4301 {
4302         return TRUE;
4303 }
4304
4305 int
4306 mono_gc_get_generation (MonoObject *obj)
4307 {
4308         if (ptr_in_nursery (obj))
4309                 return 0;
4310         return 1;
4311 }
4312
4313 void
4314 mono_gc_enable_events (void)
4315 {
4316 }
4317
4318 void
4319 mono_gc_weak_link_add (void **link_addr, MonoObject *obj, gboolean track)
4320 {
4321         sgen_register_disappearing_link (obj, link_addr, track, FALSE);
4322 }
4323
4324 void
4325 mono_gc_weak_link_remove (void **link_addr, gboolean track)
4326 {
4327         sgen_register_disappearing_link (NULL, link_addr, track, FALSE);
4328 }
4329
4330 MonoObject*
4331 mono_gc_weak_link_get (void **link_addr)
4332 {
4333         void * volatile *link_addr_volatile;
4334         void *ptr;
4335         MonoObject *obj;
4336  retry:
4337         link_addr_volatile = link_addr;
4338         ptr = (void*)*link_addr_volatile;
4339         /*
4340          * At this point we have a hidden pointer.  If the GC runs
4341          * here, it will not recognize the hidden pointer as a
4342          * reference, and if the object behind it is not referenced
4343          * elsewhere, it will be freed.  Once the world is restarted
4344          * we reveal the pointer, giving us a pointer to a freed
4345          * object.  To make sure we don't return it, we load the
4346          * hidden pointer again.  If it's still the same, we can be
4347          * sure the object reference is valid.
4348          */
4349         if (ptr)
4350                 obj = (MonoObject*) REVEAL_POINTER (ptr);
4351         else
4352                 return NULL;
4353
4354         mono_memory_barrier ();
4355
4356         /*
4357          * During the second bridge processing step the world is
4358          * running again.  That step processes all weak links once
4359          * more to null those that refer to dead objects.  Before that
4360          * is completed, those links must not be followed, so we
4361          * conservatively wait for bridge processing when any weak
4362          * link is dereferenced.
4363          */
4364         if (G_UNLIKELY (bridge_processing_in_progress))
4365                 mono_gc_wait_for_bridge_processing ();
4366
4367         if ((void*)*link_addr_volatile != ptr)
4368                 goto retry;
4369
4370         return obj;
4371 }
4372
4373 gboolean
4374 mono_gc_ephemeron_array_add (MonoObject *obj)
4375 {
4376         EphemeronLinkNode *node;
4377
4378         LOCK_GC;
4379
4380         node = sgen_alloc_internal (INTERNAL_MEM_EPHEMERON_LINK);
4381         if (!node) {
4382                 UNLOCK_GC;
4383                 return FALSE;
4384         }
4385         node->array = (char*)obj;
4386         node->next = ephemeron_list;
4387         ephemeron_list = node;
4388
4389         SGEN_LOG (5, "Registered ephemeron array %p", obj);
4390
4391         UNLOCK_GC;
4392         return TRUE;
4393 }
4394
4395 gboolean
4396 mono_gc_set_allow_synchronous_major (gboolean flag)
4397 {
4398         if (!major_collector.is_concurrent)
4399                 return flag;
4400
4401         allow_synchronous_major = flag;
4402         return TRUE;
4403 }
4404
4405 void*
4406 mono_gc_invoke_with_gc_lock (MonoGCLockedCallbackFunc func, void *data)
4407 {
4408         void *result;
4409         LOCK_INTERRUPTION;
4410         result = func (data);
4411         UNLOCK_INTERRUPTION;
4412         return result;
4413 }
4414
4415 gboolean
4416 mono_gc_is_gc_thread (void)
4417 {
4418         gboolean result;
4419         LOCK_GC;
4420         result = mono_thread_info_current () != NULL;
4421         UNLOCK_GC;
4422         return result;
4423 }
4424
4425 static gboolean
4426 is_critical_method (MonoMethod *method)
4427 {
4428         return mono_runtime_is_critical_method (method) || sgen_is_critical_method (method);
4429 }
4430
4431 void
4432 sgen_env_var_error (const char *env_var, const char *fallback, const char *description_format, ...)
4433 {
4434         va_list ap;
4435
4436         va_start (ap, description_format);
4437
4438         fprintf (stderr, "Warning: In environment variable `%s': ", env_var);
4439         vfprintf (stderr, description_format, ap);
4440         if (fallback)
4441                 fprintf (stderr, " - %s", fallback);
4442         fprintf (stderr, "\n");
4443
4444         va_end (ap);
4445 }
4446
4447 static gboolean
4448 parse_double_in_interval (const char *env_var, const char *opt_name, const char *opt, double min, double max, double *result)
4449 {
4450         char *endptr;
4451         double val = strtod (opt, &endptr);
4452         if (endptr == opt) {
4453                 sgen_env_var_error (env_var, "Using default value.", "`%s` must be a number.", opt_name);
4454                 return FALSE;
4455         }
4456         else if (val < min || val > max) {
4457                 sgen_env_var_error (env_var, "Using default value.", "`%s` must be between %.2f - %.2f.", opt_name, min, max);
4458                 return FALSE;
4459         }
4460         *result = val;
4461         return TRUE;
4462 }
4463
4464 static gboolean
4465 thread_in_critical_region (SgenThreadInfo *info)
4466 {
4467         return info->in_critical_region;
4468 }
4469
4470 void
4471 mono_gc_base_init (void)
4472 {
4473         MonoThreadInfoCallbacks cb;
4474         const char *env;
4475         char **opts, **ptr;
4476         char *major_collector_opt = NULL;
4477         char *minor_collector_opt = NULL;
4478         size_t max_heap = 0;
4479         size_t soft_limit = 0;
4480         int result;
4481         int dummy;
4482         gboolean debug_print_allowance = FALSE;
4483         double allowance_ratio = 0, save_target = 0;
4484         gboolean cement_enabled = TRUE;
4485
4486         mono_counters_init ();
4487
4488         do {
4489                 result = InterlockedCompareExchange (&gc_initialized, -1, 0);
4490                 switch (result) {
4491                 case 1:
4492                         /* already inited */
4493                         return;
4494                 case -1:
4495                         /* being inited by another thread */
4496                         g_usleep (1000);
4497                         break;
4498                 case 0:
4499                         /* we will init it */
4500                         break;
4501                 default:
4502                         g_assert_not_reached ();
4503                 }
4504         } while (result != 0);
4505
4506         SGEN_TV_GETTIME (sgen_init_timestamp);
4507
4508         LOCK_INIT (gc_mutex);
4509
4510         pagesize = mono_pagesize ();
4511         gc_debug_file = stderr;
4512
4513         cb.thread_register = sgen_thread_register;
4514         cb.thread_detach = sgen_thread_detach;
4515         cb.thread_unregister = sgen_thread_unregister;
4516         cb.thread_attach = sgen_thread_attach;
4517         cb.mono_method_is_critical = (gpointer)is_critical_method;
4518         cb.mono_thread_in_critical_region = thread_in_critical_region;
4519 #ifndef HOST_WIN32
4520         cb.thread_exit = mono_gc_pthread_exit;
4521         cb.mono_gc_pthread_create = (gpointer)mono_gc_pthread_create;
4522 #endif
4523
4524         mono_threads_init (&cb, sizeof (SgenThreadInfo));
4525
4526         LOCK_INIT (sgen_interruption_mutex);
4527
4528         if ((env = g_getenv (MONO_GC_PARAMS_NAME))) {
4529                 opts = g_strsplit (env, ",", -1);
4530                 for (ptr = opts; *ptr; ++ptr) {
4531                         char *opt = *ptr;
4532                         if (g_str_has_prefix (opt, "major=")) {
4533                                 opt = strchr (opt, '=') + 1;
4534                                 major_collector_opt = g_strdup (opt);
4535                         } else if (g_str_has_prefix (opt, "minor=")) {
4536                                 opt = strchr (opt, '=') + 1;
4537                                 minor_collector_opt = g_strdup (opt);
4538                         }
4539                 }
4540         } else {
4541                 opts = NULL;
4542         }
4543
4544         init_stats ();
4545         sgen_init_internal_allocator ();
4546         sgen_init_nursery_allocator ();
4547         sgen_init_fin_weak_hash ();
4548         sgen_init_stw ();
4549         sgen_init_hash_table ();
4550         sgen_init_descriptors ();
4551         sgen_init_gray_queues ();
4552
4553         sgen_register_fixed_internal_mem_type (INTERNAL_MEM_SECTION, SGEN_SIZEOF_GC_MEM_SECTION);
4554         sgen_register_fixed_internal_mem_type (INTERNAL_MEM_FINALIZE_READY_ENTRY, sizeof (FinalizeReadyEntry));
4555         sgen_register_fixed_internal_mem_type (INTERNAL_MEM_GRAY_QUEUE, sizeof (GrayQueueSection));
4556         sgen_register_fixed_internal_mem_type (INTERNAL_MEM_EPHEMERON_LINK, sizeof (EphemeronLinkNode));
4557
4558 #ifndef HAVE_KW_THREAD
4559         mono_native_tls_alloc (&thread_info_key, NULL);
4560 #if defined(__APPLE__) || defined (HOST_WIN32)
4561         /*
4562          * CEE_MONO_TLS requires the tls offset, not the key, so the code below only works on darwin,
4563          * where the two are the same.
4564          */
4565         mono_tls_key_set_offset (TLS_KEY_SGEN_THREAD_INFO, thread_info_key);
4566 #endif
4567 #else
4568         {
4569                 int tls_offset = -1;
4570                 MONO_THREAD_VAR_OFFSET (sgen_thread_info, tls_offset);
4571                 mono_tls_key_set_offset (TLS_KEY_SGEN_THREAD_INFO, tls_offset);
4572         }
4573 #endif
4574
4575         /*
4576          * This needs to happen before any internal allocations because
4577          * it inits the small id which is required for hazard pointer
4578          * operations.
4579          */
4580         sgen_os_init ();
4581
4582         mono_thread_info_attach (&dummy);
4583
4584         if (!minor_collector_opt) {
4585                 sgen_simple_nursery_init (&sgen_minor_collector);
4586         } else {
4587                 if (!strcmp (minor_collector_opt, "simple")) {
4588                 use_simple_nursery:
4589                         sgen_simple_nursery_init (&sgen_minor_collector);
4590                 } else if (!strcmp (minor_collector_opt, "split")) {
4591                         sgen_split_nursery_init (&sgen_minor_collector);
4592                 } else {
4593                         sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using `simple` instead.", "Unknown minor collector `%s'.", minor_collector_opt);
4594                         goto use_simple_nursery;
4595                 }
4596         }
4597
4598         if (!major_collector_opt || !strcmp (major_collector_opt, "marksweep")) {
4599         use_marksweep_major:
4600                 sgen_marksweep_init (&major_collector);
4601         } else if (!major_collector_opt || !strcmp (major_collector_opt, "marksweep-conc")) {
4602                 sgen_marksweep_conc_init (&major_collector);
4603         } else {
4604                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using `marksweep` instead.", "Unknown major collector `%s'.", major_collector_opt);
4605                 goto use_marksweep_major;
4606         }
4607
4608         ///* Keep this the default for now */
4609         /* Precise marking is broken on all supported targets. Disable until fixed. */
4610         conservative_stack_mark = TRUE;
4611
4612         sgen_nursery_size = DEFAULT_NURSERY_SIZE;
4613
4614         if (major_collector.is_concurrent)
4615                 cement_enabled = FALSE;
4616
4617         if (opts) {
4618                 gboolean usage_printed = FALSE;
4619
4620                 for (ptr = opts; *ptr; ++ptr) {
4621                         char *opt = *ptr;
4622                         if (!strcmp (opt, ""))
4623                                 continue;
4624                         if (g_str_has_prefix (opt, "major="))
4625                                 continue;
4626                         if (g_str_has_prefix (opt, "minor="))
4627                                 continue;
4628                         if (g_str_has_prefix (opt, "max-heap-size=")) {
4629                                 size_t max_heap_candidate = 0;
4630                                 opt = strchr (opt, '=') + 1;
4631                                 if (*opt && mono_gc_parse_environment_string_extract_number (opt, &max_heap_candidate)) {
4632                                         max_heap = (max_heap_candidate + mono_pagesize () - 1) & ~(size_t)(mono_pagesize () - 1);
4633                                         if (max_heap != max_heap_candidate)
4634                                                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Rounding up.", "`max-heap-size` size must be a multiple of %d.", mono_pagesize ());
4635                                 } else {
4636                                         sgen_env_var_error (MONO_GC_PARAMS_NAME, NULL, "`max-heap-size` must be an integer.");
4637                                 }
4638                                 continue;
4639                         }
4640                         if (g_str_has_prefix (opt, "soft-heap-limit=")) {
4641                                 opt = strchr (opt, '=') + 1;
4642                                 if (*opt && mono_gc_parse_environment_string_extract_number (opt, &soft_limit)) {
4643                                         if (soft_limit <= 0) {
4644                                                 sgen_env_var_error (MONO_GC_PARAMS_NAME, NULL, "`soft-heap-limit` must be positive.");
4645                                                 soft_limit = 0;
4646                                         }
4647                                 } else {
4648                                         sgen_env_var_error (MONO_GC_PARAMS_NAME, NULL, "`soft-heap-limit` must be an integer.");
4649                                 }
4650                                 continue;
4651                         }
4652                         if (g_str_has_prefix (opt, "stack-mark=")) {
4653                                 opt = strchr (opt, '=') + 1;
4654                                 if (!strcmp (opt, "precise")) {
4655                                         conservative_stack_mark = FALSE;
4656                                 } else if (!strcmp (opt, "conservative")) {
4657                                         conservative_stack_mark = TRUE;
4658                                 } else {
4659                                         sgen_env_var_error (MONO_GC_PARAMS_NAME, conservative_stack_mark ? "Using `conservative`." : "Using `precise`.",
4660                                                         "Invalid value `%s` for `stack-mark` option, possible values are: `precise`, `conservative`.", opt);
4661                                 }
4662                                 continue;
4663                         }
4664                         if (g_str_has_prefix (opt, "bridge-implementation=")) {
4665                                 opt = strchr (opt, '=') + 1;
4666                                 sgen_set_bridge_implementation (opt);
4667                                 continue;
4668                         }
4669                         if (g_str_has_prefix (opt, "toggleref-test")) {
4670                                 sgen_register_test_toggleref_callback ();
4671                                 continue;
4672                         }
4673
4674 #ifdef USER_CONFIG
4675                         if (g_str_has_prefix (opt, "nursery-size=")) {
4676                                 size_t val;
4677                                 opt = strchr (opt, '=') + 1;
4678                                 if (*opt && mono_gc_parse_environment_string_extract_number (opt, &val)) {
4679                                         if ((val & (val - 1))) {
4680                                                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default value.", "`nursery-size` must be a power of two.");
4681                                                 continue;
4682                                         }
4683
4684                                         if (val < SGEN_MAX_NURSERY_WASTE) {
4685                                                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default value.",
4686                                                                 "`nursery-size` must be at least %d bytes.", SGEN_MAX_NURSERY_WASTE);
4687                                                 continue;
4688                                         }
4689
4690                                         sgen_nursery_size = val;
4691                                         sgen_nursery_bits = 0;
4692                                         while (ONE_P << (++ sgen_nursery_bits) != sgen_nursery_size)
4693                                                 ;
4694                                 } else {
4695                                         sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default value.", "`nursery-size` must be an integer.");
4696                                         continue;
4697                                 }
4698                                 continue;
4699                         }
4700 #endif
4701                         if (g_str_has_prefix (opt, "save-target-ratio=")) {
4702                                 double val;
4703                                 opt = strchr (opt, '=') + 1;
4704                                 if (parse_double_in_interval (MONO_GC_PARAMS_NAME, "save-target-ratio", opt,
4705                                                 SGEN_MIN_SAVE_TARGET_RATIO, SGEN_MAX_SAVE_TARGET_RATIO, &val)) {
4706                                         save_target = val;
4707                                 }
4708                                 continue;
4709                         }
4710                         if (g_str_has_prefix (opt, "default-allowance-ratio=")) {
4711                                 double val;
4712                                 opt = strchr (opt, '=') + 1;
4713                                 if (parse_double_in_interval (MONO_GC_PARAMS_NAME, "default-allowance-ratio", opt,
4714                                                 SGEN_MIN_ALLOWANCE_NURSERY_SIZE_RATIO, SGEN_MIN_ALLOWANCE_NURSERY_SIZE_RATIO, &val)) {
4715                                         allowance_ratio = val;
4716                                 }
4717                                 continue;
4718                         }
4719                         if (g_str_has_prefix (opt, "allow-synchronous-major=")) {
4720                                 if (!major_collector.is_concurrent) {
4721                                         sgen_env_var_error (MONO_GC_PARAMS_NAME, "Ignoring.", "`allow-synchronous-major` is only valid for the concurrent major collector.");
4722                                         continue;
4723                                 }
4724
4725                                 opt = strchr (opt, '=') + 1;
4726
4727                                 if (!strcmp (opt, "yes")) {
4728                                         allow_synchronous_major = TRUE;
4729                                 } else if (!strcmp (opt, "no")) {
4730                                         allow_synchronous_major = FALSE;
4731                                 } else {
4732                                         sgen_env_var_error (MONO_GC_PARAMS_NAME, "Using default value.", "`allow-synchronous-major` must be either `yes' or `no'.");
4733                                         continue;
4734                                 }
4735                         }
4736
4737                         if (!strcmp (opt, "cementing")) {
4738                                 cement_enabled = TRUE;
4739                                 continue;
4740                         }
4741                         if (!strcmp (opt, "no-cementing")) {
4742                                 cement_enabled = FALSE;
4743                                 continue;
4744                         }
4745
4746                         if (major_collector.handle_gc_param && major_collector.handle_gc_param (opt))
4747                                 continue;
4748
4749                         if (sgen_minor_collector.handle_gc_param && sgen_minor_collector.handle_gc_param (opt))
4750                                 continue;
4751
4752                         sgen_env_var_error (MONO_GC_PARAMS_NAME, "Ignoring.", "Unknown option `%s`.", opt);
4753
4754                         if (usage_printed)
4755                                 continue;
4756
4757                         fprintf (stderr, "\n%s must be a comma-delimited list of one or more of the following:\n", MONO_GC_PARAMS_NAME);
4758                         fprintf (stderr, "  max-heap-size=N (where N is an integer, possibly with a k, m or a g suffix)\n");
4759                         fprintf (stderr, "  soft-heap-limit=n (where N is an integer, possibly with a k, m or a g suffix)\n");
4760                         fprintf (stderr, "  nursery-size=N (where N is an integer, possibly with a k, m or a g suffix)\n");
4761                         fprintf (stderr, "  major=COLLECTOR (where COLLECTOR is `marksweep', `marksweep-conc', `marksweep-par')\n");
4762                         fprintf (stderr, "  minor=COLLECTOR (where COLLECTOR is `simple' or `split')\n");
4763                         fprintf (stderr, "  wbarrier=WBARRIER (where WBARRIER is `remset' or `cardtable')\n");
4764                         fprintf (stderr, "  stack-mark=MARK-METHOD (where MARK-METHOD is 'precise' or 'conservative')\n");
4765                         fprintf (stderr, "  [no-]cementing\n");
4766                         if (major_collector.is_concurrent)
4767                                 fprintf (stderr, "  allow-synchronous-major=FLAG (where FLAG is `yes' or `no')\n");
4768                         if (major_collector.print_gc_param_usage)
4769                                 major_collector.print_gc_param_usage ();
4770                         if (sgen_minor_collector.print_gc_param_usage)
4771                                 sgen_minor_collector.print_gc_param_usage ();
4772                         fprintf (stderr, " Experimental options:\n");
4773                         fprintf (stderr, "  save-target-ratio=R (where R must be between %.2f - %.2f).\n", SGEN_MIN_SAVE_TARGET_RATIO, SGEN_MAX_SAVE_TARGET_RATIO);
4774                         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);
4775                         fprintf (stderr, "\n");
4776
4777                         usage_printed = TRUE;
4778                 }
4779                 g_strfreev (opts);
4780         }
4781
4782         if (major_collector_opt)
4783                 g_free (major_collector_opt);
4784
4785         if (minor_collector_opt)
4786                 g_free (minor_collector_opt);
4787
4788         alloc_nursery ();
4789
4790         if (major_collector.is_concurrent && cement_enabled) {
4791                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Ignoring.", "`cementing` is not supported on concurrent major collectors.");
4792                 cement_enabled = FALSE;
4793         }
4794
4795         sgen_cement_init (cement_enabled);
4796
4797         if ((env = g_getenv (MONO_GC_DEBUG_NAME))) {
4798                 gboolean usage_printed = FALSE;
4799
4800                 opts = g_strsplit (env, ",", -1);
4801                 for (ptr = opts; ptr && *ptr; ptr ++) {
4802                         char *opt = *ptr;
4803                         if (!strcmp (opt, ""))
4804                                 continue;
4805                         if (opt [0] >= '0' && opt [0] <= '9') {
4806                                 gc_debug_level = atoi (opt);
4807                                 opt++;
4808                                 if (opt [0] == ':')
4809                                         opt++;
4810                                 if (opt [0]) {
4811                                         char *rf = g_strdup_printf ("%s.%d", opt, mono_process_current_pid ());
4812                                         gc_debug_file = fopen (rf, "wb");
4813                                         if (!gc_debug_file)
4814                                                 gc_debug_file = stderr;
4815                                         g_free (rf);
4816                                 }
4817                         } else if (!strcmp (opt, "print-allowance")) {
4818                                 debug_print_allowance = TRUE;
4819                         } else if (!strcmp (opt, "print-pinning")) {
4820                                 sgen_pin_stats_enable ();
4821                         } else if (!strcmp (opt, "verify-before-allocs")) {
4822                                 verify_before_allocs = 1;
4823                                 has_per_allocation_action = TRUE;
4824                         } else if (g_str_has_prefix (opt, "verify-before-allocs=")) {
4825                                 char *arg = strchr (opt, '=') + 1;
4826                                 verify_before_allocs = atoi (arg);
4827                                 has_per_allocation_action = TRUE;
4828                         } else if (!strcmp (opt, "collect-before-allocs")) {
4829                                 collect_before_allocs = 1;
4830                                 has_per_allocation_action = TRUE;
4831                         } else if (g_str_has_prefix (opt, "collect-before-allocs=")) {
4832                                 char *arg = strchr (opt, '=') + 1;
4833                                 has_per_allocation_action = TRUE;
4834                                 collect_before_allocs = atoi (arg);
4835                         } else if (!strcmp (opt, "verify-before-collections")) {
4836                                 whole_heap_check_before_collection = TRUE;
4837                         } else if (!strcmp (opt, "check-at-minor-collections")) {
4838                                 consistency_check_at_minor_collection = TRUE;
4839                                 nursery_clear_policy = CLEAR_AT_GC;
4840                         } else if (!strcmp (opt, "mod-union-consistency-check")) {
4841                                 if (!major_collector.is_concurrent) {
4842                                         sgen_env_var_error (MONO_GC_DEBUG_NAME, "Ignoring.", "`mod-union-consistency-check` only works with concurrent major collector.");
4843                                         continue;
4844                                 }
4845                                 mod_union_consistency_check = TRUE;
4846                         } else if (!strcmp (opt, "check-mark-bits")) {
4847                                 check_mark_bits_after_major_collection = TRUE;
4848                         } else if (!strcmp (opt, "check-nursery-pinned")) {
4849                                 check_nursery_objects_pinned = TRUE;
4850                         } else if (!strcmp (opt, "xdomain-checks")) {
4851                                 xdomain_checks = TRUE;
4852                         } else if (!strcmp (opt, "clear-at-gc")) {
4853                                 nursery_clear_policy = CLEAR_AT_GC;
4854                         } else if (!strcmp (opt, "clear-nursery-at-gc")) {
4855                                 nursery_clear_policy = CLEAR_AT_GC;
4856                         } else if (!strcmp (opt, "clear-at-tlab-creation")) {
4857                                 nursery_clear_policy = CLEAR_AT_TLAB_CREATION;
4858                         } else if (!strcmp (opt, "debug-clear-at-tlab-creation")) {
4859                                 nursery_clear_policy = CLEAR_AT_TLAB_CREATION_DEBUG;
4860                         } else if (!strcmp (opt, "check-scan-starts")) {
4861                                 do_scan_starts_check = TRUE;
4862                         } else if (!strcmp (opt, "verify-nursery-at-minor-gc")) {
4863                                 do_verify_nursery = TRUE;
4864                         } else if (!strcmp (opt, "check-concurrent")) {
4865                                 if (!major_collector.is_concurrent) {
4866                                         sgen_env_var_error (MONO_GC_DEBUG_NAME, "Ignoring.", "`check-concurrent` only works with concurrent major collectors.");
4867                                         continue;
4868                                 }
4869                                 do_concurrent_checks = TRUE;
4870                         } else if (!strcmp (opt, "dump-nursery-at-minor-gc")) {
4871                                 do_dump_nursery_content = TRUE;
4872                         } else if (!strcmp (opt, "no-managed-allocator")) {
4873                                 sgen_set_use_managed_allocator (FALSE);
4874                         } else if (!strcmp (opt, "disable-minor")) {
4875                                 disable_minor_collections = TRUE;
4876                         } else if (!strcmp (opt, "disable-major")) {
4877                                 disable_major_collections = TRUE;
4878                         } else if (g_str_has_prefix (opt, "heap-dump=")) {
4879                                 char *filename = strchr (opt, '=') + 1;
4880                                 nursery_clear_policy = CLEAR_AT_GC;
4881                                 heap_dump_file = fopen (filename, "w");
4882                                 if (heap_dump_file) {
4883                                         fprintf (heap_dump_file, "<sgen-dump>\n");
4884                                         sgen_pin_stats_enable ();
4885                                 }
4886                         } else if (g_str_has_prefix (opt, "binary-protocol=")) {
4887                                 char *filename = strchr (opt, '=') + 1;
4888                                 char *colon = strrchr (filename, ':');
4889                                 size_t limit = -1;
4890                                 if (colon) {
4891                                         if (!mono_gc_parse_environment_string_extract_number (colon + 1, &limit)) {
4892                                                 sgen_env_var_error (MONO_GC_DEBUG_NAME, "Ignoring limit.", "Binary protocol file size limit must be an integer.");
4893                                                 limit = -1;
4894                                         }
4895                                         *colon = '\0';
4896                                 }
4897                                 binary_protocol_init (filename, (long long)limit);
4898                         } else if (!strcmp (opt, "nursery-canaries")) {
4899                                 do_verify_nursery = TRUE;
4900                                 sgen_set_use_managed_allocator (FALSE);
4901                                 enable_nursery_canaries = TRUE;
4902                         } else if (!strcmp (opt, "do-not-finalize")) {
4903                                 do_not_finalize = TRUE;
4904                         } else if (!strcmp (opt, "log-finalizers")) {
4905                                 log_finalizers = TRUE;
4906                         } else if (!sgen_bridge_handle_gc_debug (opt)) {
4907                                 sgen_env_var_error (MONO_GC_DEBUG_NAME, "Ignoring.", "Unknown option `%s`.", opt);
4908
4909                                 if (usage_printed)
4910                                         continue;
4911
4912                                 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);
4913                                 fprintf (stderr, "Valid <option>s are:\n");
4914                                 fprintf (stderr, "  collect-before-allocs[=<n>]\n");
4915                                 fprintf (stderr, "  verify-before-allocs[=<n>]\n");
4916                                 fprintf (stderr, "  check-at-minor-collections\n");
4917                                 fprintf (stderr, "  check-mark-bits\n");
4918                                 fprintf (stderr, "  check-nursery-pinned\n");
4919                                 fprintf (stderr, "  verify-before-collections\n");
4920                                 fprintf (stderr, "  verify-nursery-at-minor-gc\n");
4921                                 fprintf (stderr, "  dump-nursery-at-minor-gc\n");
4922                                 fprintf (stderr, "  disable-minor\n");
4923                                 fprintf (stderr, "  disable-major\n");
4924                                 fprintf (stderr, "  xdomain-checks\n");
4925                                 fprintf (stderr, "  check-concurrent\n");
4926                                 fprintf (stderr, "  clear-[nursery-]at-gc\n");
4927                                 fprintf (stderr, "  clear-at-tlab-creation\n");
4928                                 fprintf (stderr, "  debug-clear-at-tlab-creation\n");
4929                                 fprintf (stderr, "  check-scan-starts\n");
4930                                 fprintf (stderr, "  no-managed-allocator\n");
4931                                 fprintf (stderr, "  print-allowance\n");
4932                                 fprintf (stderr, "  print-pinning\n");
4933                                 fprintf (stderr, "  heap-dump=<filename>\n");
4934                                 fprintf (stderr, "  binary-protocol=<filename>[:<file-size-limit>]\n");
4935                                 fprintf (stderr, "  nursery-canaries\n");
4936                                 fprintf (stderr, "  do-not-finalize\n");
4937                                 fprintf (stderr, "  log-finalizers\n");
4938                                 sgen_bridge_print_gc_debug_usage ();
4939                                 fprintf (stderr, "\n");
4940
4941                                 usage_printed = TRUE;
4942                         }
4943                 }
4944                 g_strfreev (opts);
4945         }
4946
4947         if (check_mark_bits_after_major_collection)
4948                 nursery_clear_policy = CLEAR_AT_GC;
4949
4950         if (major_collector.post_param_init)
4951                 major_collector.post_param_init (&major_collector);
4952
4953         if (major_collector.needs_thread_pool)
4954                 sgen_workers_init (1);
4955
4956         sgen_memgov_init (max_heap, soft_limit, debug_print_allowance, allowance_ratio, save_target);
4957
4958         memset (&remset, 0, sizeof (remset));
4959
4960         sgen_card_table_init (&remset);
4961
4962         gc_initialized = 1;
4963 }
4964
4965 const char *
4966 mono_gc_get_gc_name (void)
4967 {
4968         return "sgen";
4969 }
4970
4971 static MonoMethod *write_barrier_conc_method;
4972 static MonoMethod *write_barrier_noconc_method;
4973
4974 gboolean
4975 sgen_is_critical_method (MonoMethod *method)
4976 {
4977         return (method == write_barrier_conc_method || method == write_barrier_noconc_method || sgen_is_managed_allocator (method));
4978 }
4979
4980 gboolean
4981 sgen_has_critical_method (void)
4982 {
4983         return write_barrier_conc_method || write_barrier_noconc_method || sgen_has_managed_allocator ();
4984 }
4985
4986 #ifndef DISABLE_JIT
4987
4988 static void
4989 emit_nursery_check (MonoMethodBuilder *mb, int *nursery_check_return_labels, gboolean is_concurrent)
4990 {
4991         int shifted_nursery_start = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg);
4992
4993         memset (nursery_check_return_labels, 0, sizeof (int) * 2);
4994         // if (ptr_in_nursery (ptr)) return;
4995         /*
4996          * Masking out the bits might be faster, but we would have to use 64 bit
4997          * immediates, which might be slower.
4998          */
4999         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5000         mono_mb_emit_byte (mb, CEE_MONO_LDPTR_NURSERY_START);
5001         mono_mb_emit_icon (mb, DEFAULT_NURSERY_BITS);
5002         mono_mb_emit_byte (mb, CEE_SHR_UN);
5003         mono_mb_emit_stloc (mb, shifted_nursery_start);
5004
5005         mono_mb_emit_ldarg (mb, 0);
5006         mono_mb_emit_icon (mb, DEFAULT_NURSERY_BITS);
5007         mono_mb_emit_byte (mb, CEE_SHR_UN);
5008         mono_mb_emit_ldloc (mb, shifted_nursery_start);
5009         nursery_check_return_labels [0] = mono_mb_emit_branch (mb, CEE_BEQ);
5010
5011         if (!is_concurrent) {
5012                 // if (!ptr_in_nursery (*ptr)) return;
5013                 mono_mb_emit_ldarg (mb, 0);
5014                 mono_mb_emit_byte (mb, CEE_LDIND_I);
5015                 mono_mb_emit_icon (mb, DEFAULT_NURSERY_BITS);
5016                 mono_mb_emit_byte (mb, CEE_SHR_UN);
5017                 mono_mb_emit_ldloc (mb, shifted_nursery_start);
5018                 nursery_check_return_labels [1] = mono_mb_emit_branch (mb, CEE_BNE_UN);
5019         }
5020 }
5021 #endif
5022
5023 MonoMethod*
5024 mono_gc_get_specific_write_barrier (gboolean is_concurrent)
5025 {
5026         MonoMethod *res;
5027         MonoMethodBuilder *mb;
5028         MonoMethodSignature *sig;
5029         MonoMethod **write_barrier_method_addr;
5030 #ifdef MANAGED_WBARRIER
5031         int i, nursery_check_labels [2];
5032
5033 #ifdef HAVE_KW_THREAD
5034         int stack_end_offset = -1;
5035
5036         MONO_THREAD_VAR_OFFSET (stack_end, stack_end_offset);
5037         g_assert (stack_end_offset != -1);
5038 #endif
5039 #endif
5040
5041         // FIXME: Maybe create a separate version for ctors (the branch would be
5042         // correctly predicted more times)
5043         if (is_concurrent)
5044                 write_barrier_method_addr = &write_barrier_conc_method;
5045         else
5046                 write_barrier_method_addr = &write_barrier_noconc_method;
5047
5048         if (*write_barrier_method_addr)
5049                 return *write_barrier_method_addr;
5050
5051         /* Create the IL version of mono_gc_barrier_generic_store () */
5052         sig = mono_metadata_signature_alloc (mono_defaults.corlib, 1);
5053         sig->ret = &mono_defaults.void_class->byval_arg;
5054         sig->params [0] = &mono_defaults.int_class->byval_arg;
5055
5056         if (is_concurrent)
5057                 mb = mono_mb_new (mono_defaults.object_class, "wbarrier_conc", MONO_WRAPPER_WRITE_BARRIER);
5058         else
5059                 mb = mono_mb_new (mono_defaults.object_class, "wbarrier_noconc", MONO_WRAPPER_WRITE_BARRIER);
5060
5061 #ifndef DISABLE_JIT
5062 #ifdef MANAGED_WBARRIER
5063         emit_nursery_check (mb, nursery_check_labels, is_concurrent);
5064         /*
5065         addr = sgen_cardtable + ((address >> CARD_BITS) & CARD_MASK)
5066         *addr = 1;
5067
5068         sgen_cardtable:
5069                 LDC_PTR sgen_cardtable
5070
5071         address >> CARD_BITS
5072                 LDARG_0
5073                 LDC_I4 CARD_BITS
5074                 SHR_UN
5075         if (SGEN_HAVE_OVERLAPPING_CARDS) {
5076                 LDC_PTR card_table_mask
5077                 AND
5078         }
5079         AND
5080         ldc_i4_1
5081         stind_i1
5082         */
5083         mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX);
5084         mono_mb_emit_byte (mb, CEE_MONO_LDPTR_CARD_TABLE);
5085         mono_mb_emit_ldarg (mb, 0);
5086         mono_mb_emit_icon (mb, CARD_BITS);
5087         mono_mb_emit_byte (mb, CEE_SHR_UN);
5088         mono_mb_emit_byte (mb, CEE_CONV_I);
5089 #ifdef SGEN_HAVE_OVERLAPPING_CARDS
5090 #if SIZEOF_VOID_P == 8
5091         mono_mb_emit_icon8 (mb, CARD_MASK);
5092 #else
5093         mono_mb_emit_icon (mb, CARD_MASK);
5094 #endif
5095         mono_mb_emit_byte (mb, CEE_CONV_I);
5096         mono_mb_emit_byte (mb, CEE_AND);
5097 #endif
5098         mono_mb_emit_byte (mb, CEE_ADD);
5099         mono_mb_emit_icon (mb, 1);
5100         mono_mb_emit_byte (mb, CEE_STIND_I1);
5101
5102         // return;
5103         for (i = 0; i < 2; ++i) {
5104                 if (nursery_check_labels [i])
5105                         mono_mb_patch_branch (mb, nursery_check_labels [i]);
5106         }
5107         mono_mb_emit_byte (mb, CEE_RET);
5108 #else
5109         mono_mb_emit_ldarg (mb, 0);
5110         mono_mb_emit_icall (mb, mono_gc_wbarrier_generic_nostore);
5111         mono_mb_emit_byte (mb, CEE_RET);
5112 #endif
5113 #endif
5114         res = mono_mb_create_method (mb, sig, 16);
5115         mono_mb_free (mb);
5116
5117         LOCK_GC;
5118         if (*write_barrier_method_addr) {
5119                 /* Already created */
5120                 mono_free_method (res);
5121         } else {
5122                 /* double-checked locking */
5123                 mono_memory_barrier ();
5124                 *write_barrier_method_addr = res;
5125         }
5126         UNLOCK_GC;
5127
5128         return *write_barrier_method_addr;
5129 }
5130
5131 MonoMethod*
5132 mono_gc_get_write_barrier (void)
5133 {
5134         return mono_gc_get_specific_write_barrier (major_collector.is_concurrent);
5135 }
5136
5137 char*
5138 mono_gc_get_description (void)
5139 {
5140         return g_strdup ("sgen");
5141 }
5142
5143 void
5144 mono_gc_set_desktop_mode (void)
5145 {
5146 }
5147
5148 gboolean
5149 mono_gc_is_moving (void)
5150 {
5151         return TRUE;
5152 }
5153
5154 gboolean
5155 mono_gc_is_disabled (void)
5156 {
5157         return FALSE;
5158 }
5159
5160 #ifdef HOST_WIN32
5161 BOOL APIENTRY mono_gc_dllmain (HMODULE module_handle, DWORD reason, LPVOID reserved)
5162 {
5163         return TRUE;
5164 }
5165 #endif
5166
5167 NurseryClearPolicy
5168 sgen_get_nursery_clear_policy (void)
5169 {
5170         return nursery_clear_policy;
5171 }
5172
5173 MonoVTable*
5174 sgen_get_array_fill_vtable (void)
5175 {
5176         if (!array_fill_vtable) {
5177                 static MonoClass klass;
5178                 static char _vtable[sizeof(MonoVTable)+8];
5179                 MonoVTable* vtable = (MonoVTable*) ALIGN_TO(_vtable, 8);
5180                 gsize bmap;
5181
5182                 MonoDomain *domain = mono_get_root_domain ();
5183                 g_assert (domain);
5184
5185                 klass.element_class = mono_defaults.byte_class;
5186                 klass.rank = 1;
5187                 klass.instance_size = sizeof (MonoArray);
5188                 klass.sizes.element_size = 1;
5189                 klass.name = "array_filler_type";
5190
5191                 vtable->klass = &klass;
5192                 bmap = 0;
5193                 vtable->gc_descr = mono_gc_make_descr_for_array (TRUE, &bmap, 0, 1);
5194                 vtable->rank = 1;
5195
5196                 array_fill_vtable = vtable;
5197         }
5198         return array_fill_vtable;
5199 }
5200
5201 void
5202 sgen_gc_lock (void)
5203 {
5204         LOCK_GC;
5205 }
5206
5207 void
5208 sgen_gc_unlock (void)
5209 {
5210         gboolean try_free = sgen_try_free_some_memory;
5211         sgen_try_free_some_memory = FALSE;
5212         mono_mutex_unlock (&gc_mutex);
5213         MONO_GC_UNLOCKED ();
5214         if (try_free)
5215                 mono_thread_hazardous_try_free_some ();
5216 }
5217
5218 void
5219 sgen_major_collector_iterate_live_block_ranges (sgen_cardtable_block_callback callback)
5220 {
5221         major_collector.iterate_live_block_ranges (callback);
5222 }
5223
5224 SgenMajorCollector*
5225 sgen_get_major_collector (void)
5226 {
5227         return &major_collector;
5228 }
5229
5230 void mono_gc_set_skip_thread (gboolean skip)
5231 {
5232         SgenThreadInfo *info = mono_thread_info_current ();
5233
5234         LOCK_GC;
5235         info->gc_disabled = skip;
5236         UNLOCK_GC;
5237 }
5238
5239 SgenRememberedSet*
5240 sgen_get_remset (void)
5241 {
5242         return &remset;
5243 }
5244
5245 guint
5246 mono_gc_get_vtable_bits (MonoClass *class)
5247 {
5248         guint res = 0;
5249         /* FIXME move this to the bridge code */
5250         if (sgen_need_bridge_processing ()) {
5251                 switch (sgen_bridge_class_kind (class)) {
5252                 case GC_BRIDGE_TRANSPARENT_BRIDGE_CLASS:
5253                 case GC_BRIDGE_OPAQUE_BRIDGE_CLASS:
5254                         res = SGEN_GC_BIT_BRIDGE_OBJECT;
5255                         break;
5256                 case GC_BRIDGE_OPAQUE_CLASS:
5257                         res = SGEN_GC_BIT_BRIDGE_OPAQUE_OBJECT;
5258                         break;
5259                 case GC_BRIDGE_TRANSPARENT_CLASS:
5260                         break;
5261                 }
5262         }
5263         if (fin_callbacks.is_class_finalization_aware) {
5264                 if (fin_callbacks.is_class_finalization_aware (class))
5265                         res |= SGEN_GC_BIT_FINALIZER_AWARE;
5266         }
5267         return res;
5268 }
5269
5270 void
5271 mono_gc_register_altstack (gpointer stack, gint32 stack_size, gpointer altstack, gint32 altstack_size)
5272 {
5273         // FIXME:
5274 }
5275
5276
5277 void
5278 sgen_check_whole_heap_stw (void)
5279 {
5280         sgen_stop_world (0);
5281         sgen_clear_nursery_fragments ();
5282         sgen_check_whole_heap (FALSE);
5283         sgen_restart_world (0, NULL);
5284 }
5285
5286 void
5287 sgen_gc_event_moves (void)
5288 {
5289         if (moved_objects_idx) {
5290                 mono_profiler_gc_moves (moved_objects, moved_objects_idx);
5291                 moved_objects_idx = 0;
5292         }
5293 }
5294
5295 gint64
5296 sgen_timestamp (void)
5297 {
5298         SGEN_TV_DECLARE (timestamp);
5299         SGEN_TV_GETTIME (timestamp);
5300         return SGEN_TV_ELAPSED (sgen_init_timestamp, timestamp);
5301 }
5302
5303 void
5304 mono_gc_register_finalizer_callbacks (MonoGCFinalizerCallbacks *callbacks)
5305 {
5306         if (callbacks->version != MONO_GC_FINALIZER_EXTENSION_VERSION)
5307                 g_error ("Invalid finalizer callback version. Expected %d but got %d\n", MONO_GC_FINALIZER_EXTENSION_VERSION, callbacks->version);
5308
5309         fin_callbacks = *callbacks;
5310 }
5311
5312
5313
5314
5315
5316 #endif /* HAVE_SGEN_GC */