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 mword total_promoted_size = 0;
  29 static mword total_promoted_size_start;
  30
  31 /*Heap limits and allocation knobs*/
  32 static mword max_heap_size = ((mword)0)- ((mword)1);
  33 static mword soft_heap_limit = ((mword)0) - ((mword)1);
  34
  35 static double default_allowance_nursery_size_ratio = SGEN_DEFAULT_ALLOWANCE_NURSERY_SIZE_RATIO;
  36 static double save_target_ratio = SGEN_DEFAULT_SAVE_TARGET_RATIO;
  37
  38 /**/
  39 static mword allocated_heap;
  40 static mword total_alloc = 0;
  41 static mword total_alloc_max = 0;
  42
  43 /* GC triggers. */
  44
  45 static gboolean debug_print_allowance = FALSE;
  46
  47
  48 /* use this to tune when to do a major/minor collection */
  49 static mword major_collection_trigger_size;
  50
  51 static mword major_pre_sweep_heap_size;
  52 static mword major_start_heap_size;
  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         total_promoted_size_start = total_promoted_size;
 164 }
 165
 166 void
 167 sgen_memgov_minor_collection_end (void)
 168 {
 169 }
 170
 171 void
 172 sgen_memgov_major_pre_sweep (void)
 173 {
 174         if (sgen_concurrent_collection_in_progress ()) {
 175                 major_pre_sweep_heap_size = get_heap_size ();
 176         } else {
 177                 /* We decrease the allowance only in the concurrent case */
 178                 major_pre_sweep_heap_size = major_start_heap_size;
 179         }
 180 }
 181
 182 void
 183 sgen_memgov_major_post_sweep (void)
 184 {
 185         mword num_major_sections = major_collector.get_num_major_sections ();
 186
 187         mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "GC_MAJOR_SWEEP: major %dK",
 188                 num_major_sections * major_collector.section_size / 1024);
 189 }
 190
 191 void
 192 sgen_memgov_major_collection_start (void)
 193 {
 194         need_calculate_minor_collection_allowance = TRUE;
 195         major_start_heap_size = get_heap_size ();
 196
 197         if (debug_print_allowance) {
 198                 SGEN_LOG (0, "Starting collection with heap size %ld bytes", (long)major_start_heap_size);
 199         }
 200 }
 201
 202 void
 203 sgen_memgov_major_collection_end (gboolean forced)
 204 {
 205         last_collection_los_memory_usage = los_memory_usage;
 206
 207         if (forced) {
 208                 sgen_get_major_collector ()->finish_sweeping ();
 209                 sgen_memgov_calculate_minor_collection_allowance ();
 210         }
 211 }
 212
 213 void
 214 sgen_memgov_collection_start (int generation)
 215 {
 216 }
 217
 218 void
 219 sgen_memgov_collection_end (int generation, GGTimingInfo* info, int info_count)
 220 {
 221         int i;
 222         for (i = 0; i < info_count; ++i) {
 223                 if (info[i].generation != -1)
 224                         sgen_client_log_timing (&info [i], total_promoted_size - total_promoted_size_start);
 225         }
 226 }
 227
 228 /*
 229 Global GC memory tracking.
 230 This tracks the total usage of memory by the GC. This includes
 231 managed and unmanaged memory.
 232 */
 233
 234 static unsigned long
 235 prot_flags_for_activate (int activate)
 236 {
 237         unsigned long prot_flags = activate? MONO_MMAP_READ|MONO_MMAP_WRITE: MONO_MMAP_NONE;
 238         return prot_flags | MONO_MMAP_PRIVATE | MONO_MMAP_ANON;
 239 }
 240
 241 void
 242 sgen_assert_memory_alloc (void *ptr, size_t requested_size, const char *assert_description)
 243 {
 244         if (ptr || !assert_description)
 245                 return;
 246         fprintf (stderr, "Error: Garbage collector could not allocate %zu bytes of memory for %s.\n", requested_size, assert_description);
 247         exit (1);
 248 }
 249
 250 /*
 251  * Allocate a big chunk of memory from the OS (usually 64KB to several megabytes).
 252  * This must not require any lock.
 253  */
 254 void*
 255 sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char *assert_description)
 256 {
 257         void *ptr;
 258
 259         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 260
 261         ptr = mono_valloc (0, size, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 262         sgen_assert_memory_alloc (ptr, size, assert_description);
 263         if (ptr) {
 264                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 265                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 266         }
 267         return ptr;
 268 }
 269
 270 /* size must be a power of 2 */
 271 void*
 272 sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char *assert_description)
 273 {
 274         void *ptr;
 275
 276         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 277
 278         ptr = mono_valloc_aligned (size, alignment, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 279         sgen_assert_memory_alloc (ptr, size, assert_description);
 280         if (ptr) {
 281                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 282                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 283         }
 284         return ptr;
 285 }
 286
 287 /*
 288  * Free the memory returned by sgen_alloc_os_memory (), returning it to the OS.
 289  */
 290 void
 291 sgen_free_os_memory (void *addr, size_t size, SgenAllocFlags flags)
 292 {
 293         g_assert (!(flags & ~SGEN_ALLOC_HEAP));
 294
 295         mono_vfree (addr, size);
 296         SGEN_ATOMIC_ADD_P (total_alloc, -(gssize)size);
 297         total_alloc_max = MAX (total_alloc_max, total_alloc);
 298 }
 299
 300 size_t
 301 sgen_gc_get_total_heap_allocation (void)
 302 {
 303         return total_alloc;
 304 }
 305
 306
 307 /*
 308 Heap Sizing limits.
 309 This limit the max size of the heap. It takes into account
 310 only memory actively in use to hold heap objects and not
 311 for other parts of the GC.
 312  */
 313 static mword
 314 sgen_memgov_available_free_space (void)
 315 {
 316         return max_heap_size - MIN (allocated_heap, max_heap_size);
 317 }
 318
 319 void
 320 sgen_memgov_release_space (mword size, int space)
 321 {
 322         SGEN_ATOMIC_ADD_P (allocated_heap, -(gssize)size);
 323 }
 324
 325 gboolean
 326 sgen_memgov_try_alloc_space (mword size, int space)
 327 {
 328         if (sgen_memgov_available_free_space () < size) {
 329                 SGEN_ASSERT (4, !sgen_thread_pool_is_thread_pool_thread (mono_native_thread_id_get ()), "Memory shouldn't run out in worker thread");
 330                 return FALSE;
 331         }
 332
 333         SGEN_ATOMIC_ADD_P (allocated_heap, size);
 334         sgen_client_total_allocated_heap_changed (allocated_heap);
 335         return TRUE;
 336 }
 337
 338 void
 339 sgen_memgov_init (size_t max_heap, size_t soft_limit, gboolean debug_allowance, double allowance_ratio, double save_target)
 340 {
 341         if (soft_limit)
 342                 soft_heap_limit = soft_limit;
 343
 344         debug_print_allowance = debug_allowance;
 345         major_collection_trigger_size = MIN_MINOR_COLLECTION_ALLOWANCE;
 346
 347         mono_counters_register ("Memgov alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_VARIABLE, &total_alloc);
 348         mono_counters_register ("Memgov max alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_MONOTONIC, &total_alloc_max);
 349
 350         if (max_heap == 0)
 351                 return;
 352
 353         if (max_heap < soft_limit) {
 354                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Setting to minimum.", "`max-heap-size` must be at least as large as `soft-heap-limit`.");
 355                 max_heap = soft_limit;
 356         }
 357
 358         if (max_heap < sgen_nursery_size * 4) {
 359                 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`.");
 360                 max_heap = sgen_nursery_size * 4;
 361         }
 362         max_heap_size = max_heap - sgen_nursery_size;
 363
 364         if (allowance_ratio)
 365                 default_allowance_nursery_size_ratio = allowance_ratio;
 366
 367         if (save_target)
 368                 save_target_ratio = save_target;
 369 }
 370
 371 #endif