mono/sgen/sgen-memory-governor.c

   1 /*
   2  * sgen-memory-governor.c: When to schedule collections based on
   3  * memory usage.
   4  *
   5  * Author:
   6  *      Rodrigo Kumpera (rkumpera@novell.com)
   7  *
   8  * Copyright 2001-2003 Ximian, Inc
   9  * Copyright 2003-2010 Novell, Inc.
  10  * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
  11  * Copyright (C) 2012 Xamarin Inc
  12  *
  13  * Licensed under the MIT license. See LICENSE file in the project root for full license information.
  14  */
  15
  16 #include "config.h"
  17 #ifdef HAVE_SGEN_GC
  18
  19 #include <stdlib.h>
  20
  21 #include "mono/sgen/sgen-gc.h"
  22 #include "mono/sgen/sgen-memory-governor.h"
  23 #include "mono/sgen/sgen-thread-pool.h"
  24 #include "mono/sgen/sgen-client.h"
  25
  26 #define MIN_MINOR_COLLECTION_ALLOWANCE  ((mword)(DEFAULT_NURSERY_SIZE * default_allowance_nursery_size_ratio))
  27
  28 /*Heap limits and allocation knobs*/
  29 static mword max_heap_size = ((mword)0)- ((mword)1);
  30 static mword soft_heap_limit = ((mword)0) - ((mword)1);
  31
  32 static double default_allowance_nursery_size_ratio = SGEN_DEFAULT_ALLOWANCE_NURSERY_SIZE_RATIO;
  33 static double save_target_ratio = SGEN_DEFAULT_SAVE_TARGET_RATIO;
  34
  35 /**/
  36 static mword allocated_heap;
  37 static mword total_alloc = 0;
  38 static mword total_alloc_max = 0;
  39
  40 /* GC triggers. */
  41
  42 static gboolean debug_print_allowance = FALSE;
  43
  44
  45 /* use this to tune when to do a major/minor collection */
  46 static mword major_collection_trigger_size;
  47
  48 static mword major_pre_sweep_heap_size;
  49 static mword major_start_heap_size;
  50
  51 static mword last_major_num_sections = 0;
  52 static mword last_los_memory_usage = 0;
  53
  54 static gboolean need_calculate_minor_collection_allowance;
  55
  56 /* The size of the LOS after the last major collection, after sweeping. */
  57 static mword last_collection_los_memory_usage = 0;
  58
  59 static mword sgen_memgov_available_free_space (void);
  60
  61
  62 /* GC trigger heuristics. */
  63
  64 static void
  65 sgen_memgov_calculate_minor_collection_allowance (void)
  66 {
  67         size_t new_major, new_heap_size, allowance_target, allowance;
  68         size_t decrease;
  69
  70         if (!need_calculate_minor_collection_allowance)
  71                 return;
  72
  73         SGEN_ASSERT (0, major_collector.have_swept (), "Can only calculate allowance if heap is swept");
  74
  75         new_major = major_collector.get_bytes_survived_last_sweep ();
  76         new_heap_size = new_major + last_collection_los_memory_usage;
  77
  78         /*
  79          * We allow the heap to grow by one third its current size before we start the next
  80          * major collection.
  81          */
  82         allowance_target = new_heap_size * SGEN_DEFAULT_ALLOWANCE_HEAP_SIZE_RATIO;
  83
  84         allowance = MAX (allowance_target, MIN_MINOR_COLLECTION_ALLOWANCE);
  85
  86         /*
  87          * For the concurrent collector, we decrease the allowance relative to the memory
  88          * growth during the M&S phase, survival rate of the collection and the allowance
  89          * ratio.
  90          */
  91         decrease = (major_pre_sweep_heap_size - major_start_heap_size) * ((float)new_heap_size / major_pre_sweep_heap_size) * (SGEN_DEFAULT_ALLOWANCE_HEAP_SIZE_RATIO + 1);
  92         if (decrease > allowance)
  93                 decrease = allowance;
  94         allowance -= decrease;
  95
  96         if (new_heap_size + allowance > soft_heap_limit) {
  97                 if (new_heap_size > soft_heap_limit)
  98                         allowance = MIN_MINOR_COLLECTION_ALLOWANCE;
  99                 else
 100                         allowance = MAX (soft_heap_limit - new_heap_size, MIN_MINOR_COLLECTION_ALLOWANCE);
 101         }
 102
 103         /* FIXME: Why is this here? */
 104         if (major_collector.free_swept_blocks)
 105                 major_collector.free_swept_blocks (allowance);
 106
 107         major_collection_trigger_size = new_heap_size + allowance;
 108
 109         need_calculate_minor_collection_allowance = FALSE;
 110
 111         if (debug_print_allowance) {
 112                 SGEN_LOG (0, "Surviving sweep: %ld bytes (%ld major, %ld LOS)", (long)new_heap_size, (long)new_major, (long)last_collection_los_memory_usage);
 113                 SGEN_LOG (0, "Allowance: %ld bytes", (long)allowance);
 114                 SGEN_LOG (0, "Trigger size: %ld bytes", (long)major_collection_trigger_size);
 115         }
 116 }
 117
 118 static inline size_t
 119 get_heap_size (void)
 120 {
 121         return major_collector.get_num_major_sections () * major_collector.section_size + los_memory_usage;
 122 }
 123
 124 gboolean
 125 sgen_need_major_collection (mword space_needed)
 126 {
 127         size_t heap_size;
 128
 129         if (sgen_concurrent_collection_in_progress ()) {
 130                 heap_size = get_heap_size ();
 131
 132                 if (heap_size <= major_collection_trigger_size)
 133                         return FALSE;
 134
 135                 /*
 136                  * The more the heap grows, the more we need to decrease the allowance above,
 137                  * in order to have similar trigger sizes as the synchronous collector.
 138                  * If the heap grows so much that we would need to have a negative allowance,
 139                  * we force the finishing of the collection, to avoid increased memory usage.
 140                  */
 141                 if ((heap_size - major_start_heap_size) > major_start_heap_size * SGEN_DEFAULT_ALLOWANCE_HEAP_SIZE_RATIO)
 142                         return TRUE;
 143                 return FALSE;
 144         }
 145
 146         /* FIXME: This is a cop-out.  We should have some way of figuring this out. */
 147         if (!major_collector.have_swept ())
 148                 return FALSE;
 149
 150         if (space_needed > sgen_memgov_available_free_space ())
 151                 return TRUE;
 152
 153         sgen_memgov_calculate_minor_collection_allowance ();
 154
 155         heap_size = get_heap_size ();
 156
 157         return heap_size > major_collection_trigger_size;
 158 }
 159
 160 void
 161 sgen_memgov_minor_collection_start (void)
 162 {
 163 }
 164
 165 void
 166 sgen_memgov_minor_collection_end (void)
 167 {
 168 }
 169
 170 void
 171 sgen_memgov_major_pre_sweep (void)
 172 {
 173         if (sgen_concurrent_collection_in_progress ()) {
 174                 major_pre_sweep_heap_size = get_heap_size ();
 175         } else {
 176                 /* We decrease the allowance only in the concurrent case */
 177                 major_pre_sweep_heap_size = major_start_heap_size;
 178         }
 179 }
 180
 181 void
 182 sgen_memgov_major_post_sweep (void)
 183 {
 184         mword num_major_sections = major_collector.get_num_major_sections ();
 185
 186         mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "GC_MAJOR_SWEEP: major %dK/%dK",
 187                 num_major_sections * major_collector.section_size / 1024,
 188                 last_major_num_sections * major_collector.section_size / 1024);
 189         last_major_num_sections = num_major_sections;
 190 }
 191
 192 void
 193 sgen_memgov_major_collection_start (void)
 194 {
 195         need_calculate_minor_collection_allowance = TRUE;
 196         major_start_heap_size = get_heap_size ();
 197
 198         if (debug_print_allowance) {
 199                 SGEN_LOG (0, "Starting collection with heap size %ld bytes", (long)major_start_heap_size);
 200         }
 201 }
 202
 203 void
 204 sgen_memgov_major_collection_end (gboolean forced)
 205 {
 206         last_collection_los_memory_usage = los_memory_usage;
 207
 208         if (forced) {
 209                 sgen_get_major_collector ()->finish_sweeping ();
 210                 sgen_memgov_calculate_minor_collection_allowance ();
 211         }
 212 }
 213
 214 void
 215 sgen_memgov_collection_start (int generation)
 216 {
 217 }
 218
 219 void
 220 sgen_memgov_collection_end (int generation, GGTimingInfo* info, int info_count)
 221 {
 222         int i;
 223         for (i = 0; i < info_count; ++i) {
 224                 if (info[i].generation != -1)
 225                         sgen_client_log_timing (&info [i], last_major_num_sections, last_los_memory_usage);
 226         }
 227         last_los_memory_usage = los_memory_usage;
 228 }
 229
 230 /*
 231 Global GC memory tracking.
 232 This tracks the total usage of memory by the GC. This includes
 233 managed and unmanaged memory.
 234 */
 235
 236 static unsigned long
 237 prot_flags_for_activate (int activate)
 238 {
 239         unsigned long prot_flags = activate? MONO_MMAP_READ|MONO_MMAP_WRITE: MONO_MMAP_NONE;
 240         return prot_flags | MONO_MMAP_PRIVATE | MONO_MMAP_ANON;
 241 }
 242
 243 void
 244 sgen_assert_memory_alloc (void *ptr, size_t requested_size, const char *assert_description)
 245 {
 246         if (ptr || !assert_description)
 247                 return;
 248         fprintf (stderr, "Error: Garbage collector could not allocate %zu bytes of memory for %s.\n", requested_size, assert_description);
 249         exit (1);
 250 }
 251
 252 /*
 253  * Allocate a big chunk of memory from the OS (usually 64KB to several megabytes).
 254  * This must not require any lock.
 255  */
 256 void*
 257 sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char *assert_description)
 258 {
 259         void *ptr;
 260
 261         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 262
 263         ptr = mono_valloc (0, size, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 264         sgen_assert_memory_alloc (ptr, size, assert_description);
 265         if (ptr) {
 266                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 267                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 268         }
 269         return ptr;
 270 }
 271
 272 /* size must be a power of 2 */
 273 void*
 274 sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char *assert_description)
 275 {
 276         void *ptr;
 277
 278         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 279
 280         ptr = mono_valloc_aligned (size, alignment, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 281         sgen_assert_memory_alloc (ptr, size, assert_description);
 282         if (ptr) {
 283                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 284                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 285         }
 286         return ptr;
 287 }
 288
 289 /*
 290  * Free the memory returned by sgen_alloc_os_memory (), returning it to the OS.
 291  */
 292 void
 293 sgen_free_os_memory (void *addr, size_t size, SgenAllocFlags flags)
 294 {
 295         g_assert (!(flags & ~SGEN_ALLOC_HEAP));
 296
 297         mono_vfree (addr, size);
 298         SGEN_ATOMIC_ADD_P (total_alloc, -(gssize)size);
 299         total_alloc_max = MAX (total_alloc_max, total_alloc);
 300 }
 301
 302 size_t
 303 sgen_gc_get_total_heap_allocation (void)
 304 {
 305         return total_alloc;
 306 }
 307
 308
 309 /*
 310 Heap Sizing limits.
 311 This limit the max size of the heap. It takes into account
 312 only memory actively in use to hold heap objects and not
 313 for other parts of the GC.
 314  */
 315 static mword
 316 sgen_memgov_available_free_space (void)
 317 {
 318         return max_heap_size - MIN (allocated_heap, max_heap_size);
 319 }
 320
 321 void
 322 sgen_memgov_release_space (mword size, int space)
 323 {
 324         SGEN_ATOMIC_ADD_P (allocated_heap, -(gssize)size);
 325 }
 326
 327 gboolean
 328 sgen_memgov_try_alloc_space (mword size, int space)
 329 {
 330         if (sgen_memgov_available_free_space () < size) {
 331                 SGEN_ASSERT (4, !sgen_thread_pool_is_thread_pool_thread (mono_native_thread_id_get ()), "Memory shouldn't run out in worker thread");
 332                 return FALSE;
 333         }
 334
 335         SGEN_ATOMIC_ADD_P (allocated_heap, size);
 336         sgen_client_total_allocated_heap_changed (allocated_heap);
 337         return TRUE;
 338 }
 339
 340 void
 341 sgen_memgov_init (size_t max_heap, size_t soft_limit, gboolean debug_allowance, double allowance_ratio, double save_target)
 342 {
 343         if (soft_limit)
 344                 soft_heap_limit = soft_limit;
 345
 346         debug_print_allowance = debug_allowance;
 347         major_collection_trigger_size = MIN_MINOR_COLLECTION_ALLOWANCE;
 348
 349         mono_counters_register ("Memgov alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_VARIABLE, &total_alloc);
 350         mono_counters_register ("Memgov max alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_MONOTONIC, &total_alloc_max);
 351
 352         if (max_heap == 0)
 353                 return;
 354
 355         if (max_heap < soft_limit) {
 356                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Setting to minimum.", "`max-heap-size` must be at least as large as `soft-heap-limit`.");
 357                 max_heap = soft_limit;
 358         }
 359
 360         if (max_heap < sgen_nursery_size * 4) {
 361                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Setting to minimum.", "`max-heap-size` must be at least 4 times as large as `nursery size`.");
 362                 max_heap = sgen_nursery_size * 4;
 363         }
 364         max_heap_size = max_heap - sgen_nursery_size;
 365
 366         if (allowance_ratio)
 367                 default_allowance_nursery_size_ratio = allowance_ratio;
 368
 369         if (save_target)
 370                 save_target_ratio = save_target;
 371 }
 372
 373 #endif