mono/sgen/sgen-conf.h

   1 /**
   2  * \file
   3  * Tunable parameters and debugging switches.
   4  *
   5  * Copyright 2001-2003 Ximian, Inc
   6  * Copyright 2003-2010 Novell, Inc.
   7  * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
   8  * Copyright (C) 2012 Xamarin Inc
   9  *
  10  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  11  */
  12 #ifndef __MONO_SGENCONF_H__
  13 #define __MONO_SGENCONF_H__
  14
  15 #include <glib.h>
  16
  17 /*Basic defines and static tunables */
  18
  19 #if SIZEOF_VOID_P == 4
  20 typedef guint32 mword;
  21 #else
  22 typedef guint64 mword;
  23 #endif
  24
  25 #if TARGET_SIZEOF_VOID_P == 4
  26 typedef guint32 target_mword;
  27 #else
  28 typedef guint64 target_mword;
  29 #endif
  30
  31 /* This neeeds to be target specific since its embedded in vtables */
  32 typedef target_mword SgenDescriptor;
  33 #define SGEN_DESCRIPTOR_NULL    0
  34
  35 /*
  36  * Turning on heavy statistics will turn off the managed allocator and
  37  * the managed write barrier.
  38  */
  39 // #define HEAVY_STATISTICS
  40
  41 #ifdef HEAVY_STATISTICS
  42 #define HEAVY_STAT(x)   x
  43 #else
  44 #define HEAVY_STAT(x)
  45 #endif
  46
  47 /*
  48  * The binary protocol enables logging a lot of the GC ativity in a way that is not very
  49  * intrusive and produces a compact file that can be searched using a custom tool.  This
  50  * option enables very fine-grained binary protocol events, which will make the GC a tiny
  51  * bit less efficient even if no binary protocol file is generated.
  52  */
  53 //#define SGEN_HEAVY_BINARY_PROTOCOL
  54
  55 /*
  56  * This extends the heavy binary protocol to record the provenance of an object
  57  * for every allocation.
  58  */
  59 //#define SGEN_OBJECT_PROVENANCE
  60
  61 /*
  62  * This enables checks whenever objects are enqueued in gray queues.
  63  * Right now the only check done is that we never enqueue nursery
  64  * pointers in the concurrent collector.
  65  */
  66 //#define SGEN_CHECK_GRAY_OBJECT_ENQUEUE
  67
  68 /*
  69  * This keeps track of where a gray object queue section is and
  70  * whether it is where it should be.
  71  */
  72 //#define SGEN_CHECK_GRAY_OBJECT_SECTIONS
  73
  74 /*
  75  * Enable this to check every reference update for null references and whether the update is
  76  * made in a worker thread.  In only a few cases do we potentially update references by
  77  * writing nulls, so we assert in all the cases where it's not allowed.  The concurrent
  78  * collector's worker thread is not allowed to update references at all, so we also assert
  79  * that we're not in the worker thread.
  80  */
  81 //#define SGEN_CHECK_UPDATE_REFERENCE
  82
  83 /*
  84  * Define this and use the "xdomain-checks" MONO_GC_DEBUG option to
  85  * have cross-domain checks in the write barrier.
  86  */
  87 //#define XDOMAIN_CHECKS_IN_WBARRIER
  88
  89 /*
  90  * Define this to get number of objects marked information in the
  91  * concurrent GC DTrace probes.  Has a small performance impact, so
  92  * it's disabled by default.
  93  */
  94 //#define SGEN_COUNT_NUMBER_OF_MAJOR_OBJECTS_MARKED
  95
  96 /*
  97  * Object layout statistics gather a histogram of reference locations
  98  * over all scanned objects.  We use this information to improve GC
  99  * descriptors to speed up scanning.  This does not provide any
 100  * troubleshooting assistance (unless you are troubled in highly
 101  * unusual ways) and makes scanning slower.
 102  */
 103 //#define SGEN_OBJECT_LAYOUT_STATISTICS
 104
 105 #ifndef SGEN_HEAVY_BINARY_PROTOCOL
 106 #ifndef HEAVY_STATISTICS
 107 #define MANAGED_ALLOCATION
 108 #ifndef XDOMAIN_CHECKS_IN_WBARRIER
 109 #define MANAGED_WBARRIER
 110 #endif
 111 #endif
 112 #endif
 113
 114 #if defined (HOST_WASM)
 115 #define DEFAULT_MAJOR SGEN_MAJOR_SERIAL
 116 #define DEFAULT_SWEEP_MODE SGEN_SWEEP_SERIAL
 117 #elif defined(HAVE_CONC_GC_AS_DEFAULT)
 118 /* Use concurrent major on deskstop platforms */
 119 #define DEFAULT_MAJOR SGEN_MAJOR_CONCURRENT
 120 #define DEFAULT_SWEEP_MODE SGEN_SWEEP_CONCURRENT
 121 #else
 122 #define DEFAULT_MAJOR SGEN_MAJOR_SERIAL
 123 #define DEFAULT_SWEEP_MODE SGEN_SWEEP_CONCURRENT
 124 #endif
 125
 126
 127
 128 /*
 129  * Maximum level of debug to enable on this build.
 130  * Making this a constant enables us to put logging in a lot of places and
 131  * not pay its cost on release builds.
 132  */
 133 #define SGEN_MAX_DEBUG_LEVEL 2
 134
 135 /*
 136  * Maximum level of asserts to enable on this build.
 137  * FIXME replace all magic numbers with defines.
 138  */
 139 #define SGEN_MAX_ASSERT_LEVEL 5
 140
 141
 142 #define GC_BITS_PER_WORD (sizeof (mword) * 8)
 143
 144 /*Size of the section used by the copying GC. */
 145 #define SGEN_SIZEOF_GC_MEM_SECTION      ((sizeof (GCMemSection) + 7) & ~7)
 146
 147 /*
 148  * to quickly find the head of an object pinned by a conservative
 149  * address we keep track of the objects allocated for each
 150  * SGEN_SCAN_START_SIZE memory chunk in the nursery or other memory
 151  * sections. Larger values have less memory overhead and bigger
 152  * runtime cost. 4-8 KB are reasonable values.
 153  */
 154 #define SGEN_SCAN_START_SIZE (4096*2)
 155
 156 /*
 157  * Objects bigger then this go into the large object space.  This size has a few
 158  * constraints.  At least two of them must fit into a major heap block.  It must also play
 159  * well with the run length GC descriptor, which encodes the object size.
 160  */
 161 #define SGEN_MAX_SMALL_OBJ_SIZE 8000
 162
 163 /*
 164  * This is the maximum ammount of memory we're willing to waste in order to speed up allocation.
 165  * Wastage comes in thre forms:
 166  *
 167  * -when building the nursery fragment list, small regions are discarded;
 168  * -when allocating memory from a fragment if it ends up below the threshold, we remove it from the fragment list; and
 169  * -when allocating a new tlab, we discard the remaining space of the old one
 170  *
 171  * Increasing this value speeds up allocation but will cause more frequent nursery collections as less space will be used.
 172  * Descreasing this value will cause allocation to be slower since we'll have to cycle thru more fragments.
 173  * 512 annedoctally keeps wastage under control and doesn't impact allocation performance too much.
 174 */
 175 #define SGEN_MAX_NURSERY_WASTE 512
 176
 177
 178 /*
 179  * Max nursery size that we support.
 180  *
 181  * We depend on an array of longs to mark empty sections and we only support 4 byte indexes
 182  */
 183 #if SIZEOF_VOID_P == 8
 184 #define SGEN_MAX_NURSERY_SIZE ((mword)1 << 35)
 185 #endif
 186
 187 /*
 188  * Minimum allowance for nursery allocations, as a multiple of the size of nursery.
 189  *
 190  * We allow at least this much allocation to happen to the major heap from multiple
 191  * minor collections before triggering a major collection.
 192  *
 193  * Bigger values increases throughput by allowing more garbage to sit in the major heap.
 194  * Smaller values leads to better memory effiency but more frequent major collections.
 195  */
 196 #define SGEN_DEFAULT_ALLOWANCE_NURSERY_SIZE_RATIO 4.0
 197
 198 #define SGEN_MIN_ALLOWANCE_NURSERY_SIZE_RATIO 1.0
 199 #define SGEN_MAX_ALLOWANCE_NURSERY_SIZE_RATIO 10.0
 200
 201 /*
 202  * How much more we allow the heap to grow before triggering another major collection
 203  */
 204 #define SGEN_DEFAULT_ALLOWANCE_HEAP_SIZE_RATIO 0.33
 205
 206 /*
 207  * Default ratio of memory we want to release in a major collection in relation to the the current heap size.
 208  *
 209  * A major collection target is to free a given amount of memory. This amount is a ratio of the major heap size.
 210  *
 211  * Values above 0.5 cause the heap to agressively grow when it's small and waste memory when it's big.
 212  * Lower values will produce more reasonable sized heaps when it's small, but will be suboptimal at large
 213  * sizes as they will use a small fraction only.
 214  *
 215  */
 216 #define SGEN_DEFAULT_SAVE_TARGET_RATIO 0.5
 217
 218 #define SGEN_MIN_SAVE_TARGET_RATIO 0.1
 219 #define SGEN_MAX_SAVE_TARGET_RATIO 2.0
 220
 221 /*
 222  * Configurable cementing parameters.
 223  *
 224  * If there are too many pinned nursery objects with many references
 225  * from the major heap, the hash table size must be increased.
 226  *
 227  * The threshold is the number of references from the major heap to a
 228  * pinned nursery object which triggers cementing: if there are more
 229  * than that number of references, the pinned object is cemented until
 230  * the next major collection.
 231  */
 232 #define SGEN_CEMENT_HASH_SHIFT  6
 233 #define SGEN_CEMENT_HASH_SIZE   (1 << SGEN_CEMENT_HASH_SHIFT)
 234 #define SGEN_CEMENT_HASH(hv)    (((hv) ^ ((hv) >> SGEN_CEMENT_HASH_SHIFT)) & (SGEN_CEMENT_HASH_SIZE - 1))
 235 #define SGEN_CEMENT_THRESHOLD   1000
 236
 237 /*
 238  * Default values for the nursery size
 239  */
 240 #define SGEN_DEFAULT_NURSERY_MIN_SIZE   (1 << 19)
 241 #define SGEN_DEFAULT_NURSERY_SIZE       (1 << 22)
 242 #define SGEN_DEFAULT_NURSERY_MAX_SIZE   (1 << 25)
 243
 244 /*
 245  * We are trying to keep pauses lower than this (ms). We use it for dynamic nursery
 246  * sizing heuristics. We are keeping leeway in order to be prepared for work-load
 247  * variations.
 248  */
 249 #define SGEN_DEFAULT_MAX_PAUSE_TIME 30
 250 #define SGEN_DEFAULT_MAX_PAUSE_MARGIN 0.66f
 251
 252
 253 #define SGEN_PAUSE_MODE_MAX_PAUSE_MARGIN 0.5f
 254
 255 /*
 256  * In practice, for nurseries smaller than this, the parallel minor tends to be
 257  * ineffective, even leading to regressions. Avoid using it for smaller nurseries.
 258  */
 259 #define SGEN_PARALLEL_MINOR_MIN_NURSERY_SIZE (1 << 24)
 260
 261 #endif