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