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 last_major_num_sections = 0;
  60 static mword last_los_memory_usage = 0;
  61
  62 static gboolean need_calculate_minor_collection_allowance;
  63
  64 /* The size of the LOS after the last major collection, after sweeping. */
  65 static mword last_collection_los_memory_usage = 0;
  66
  67 static mword sgen_memgov_available_free_space (void);
  68
  69
  70 /* GC trigger heuristics. */
  71
  72 static void
  73 sgen_memgov_calculate_minor_collection_allowance (void)
  74 {
  75         size_t new_major, new_heap_size, allowance_target, allowance;
  76
  77         if (!need_calculate_minor_collection_allowance)
  78                 return;
  79
  80         SGEN_ASSERT (0, major_collector.have_swept (), "Can only calculate allowance if heap is swept");
  81
  82         new_major = major_collector.get_bytes_survived_last_sweep ();
  83         new_heap_size = new_major + last_collection_los_memory_usage;
  84
  85         /*
  86          * We allow the heap to grow by one third its current size before we start the next
  87          * major collection.
  88          */
  89         allowance_target = new_heap_size * SGEN_DEFAULT_ALLOWANCE_HEAP_SIZE_RATIO;
  90
  91         allowance = MAX (allowance_target, MIN_MINOR_COLLECTION_ALLOWANCE);
  92
  93         if (new_heap_size + allowance > soft_heap_limit) {
  94                 if (new_heap_size > soft_heap_limit)
  95                         allowance = MIN_MINOR_COLLECTION_ALLOWANCE;
  96                 else
  97                         allowance = MAX (soft_heap_limit - new_heap_size, MIN_MINOR_COLLECTION_ALLOWANCE);
  98         }
  99
 100         /* FIXME: Why is this here? */
 101         if (major_collector.free_swept_blocks)
 102                 major_collector.free_swept_blocks (allowance);
 103
 104         major_collection_trigger_size = new_heap_size + allowance;
 105
 106         need_calculate_minor_collection_allowance = FALSE;
 107
 108         if (debug_print_allowance) {
 109                 SGEN_LOG (0, "Surviving sweep: %ld bytes (%ld major, %ld LOS)", (long)new_heap_size, (long)new_major, (long)last_collection_los_memory_usage);
 110                 SGEN_LOG (0, "Allowance: %ld bytes", (long)allowance);
 111                 SGEN_LOG (0, "Trigger size: %ld bytes", (long)major_collection_trigger_size);
 112         }
 113 }
 114
 115 static inline size_t
 116 get_heap_size (void)
 117 {
 118         return major_collector.get_num_major_sections () * major_collector.section_size + los_memory_usage;
 119 }
 120
 121 gboolean
 122 sgen_need_major_collection (mword space_needed)
 123 {
 124         size_t heap_size;
 125
 126         if (sgen_concurrent_collection_in_progress ()) {
 127                 heap_size = get_heap_size ();
 128
 129                 if (heap_size <= major_collection_trigger_size)
 130                         return FALSE;
 131
 132                 /* We allow the heap to grow an additional third of the allowance during a concurrent collection */
 133                 if ((heap_size - major_collection_trigger_size) >
 134                                 (major_collection_trigger_size
 135                                 * (SGEN_DEFAULT_ALLOWANCE_HEAP_SIZE_RATIO / (SGEN_DEFAULT_ALLOWANCE_HEAP_SIZE_RATIO + 1))
 136                                 * SGEN_DEFAULT_CONCURRENT_HEAP_ALLOWANCE_RATIO)) {
 137                         return TRUE;
 138                 }
 139                 return FALSE;
 140         }
 141
 142         /* FIXME: This is a cop-out.  We should have some way of figuring this out. */
 143         if (!major_collector.have_swept ())
 144                 return FALSE;
 145
 146         if (space_needed > sgen_memgov_available_free_space ())
 147                 return TRUE;
 148
 149         sgen_memgov_calculate_minor_collection_allowance ();
 150
 151         heap_size = get_heap_size ();
 152
 153         return heap_size > major_collection_trigger_size;
 154 }
 155
 156 void
 157 sgen_memgov_minor_collection_start (void)
 158 {
 159 }
 160
 161 void
 162 sgen_memgov_minor_collection_end (void)
 163 {
 164 }
 165
 166 void
 167 sgen_memgov_major_collection_start (void)
 168 {
 169         need_calculate_minor_collection_allowance = TRUE;
 170
 171         if (debug_print_allowance) {
 172                 SGEN_LOG (0, "Starting collection with heap size %ld bytes", (long)get_heap_size ());
 173         }
 174 }
 175
 176 void
 177 sgen_memgov_major_collection_end (gboolean forced)
 178 {
 179         last_collection_los_memory_usage = los_memory_usage;
 180
 181         if (forced) {
 182                 sgen_get_major_collector ()->finish_sweeping ();
 183                 sgen_memgov_calculate_minor_collection_allowance ();
 184         }
 185 }
 186
 187 void
 188 sgen_memgov_collection_start (int generation)
 189 {
 190 }
 191
 192 void
 193 sgen_memgov_collection_end (int generation, GGTimingInfo* info, int info_count)
 194 {
 195         int i;
 196         for (i = 0; i < info_count; ++i) {
 197                 if (info[i].generation != -1)
 198                         sgen_client_log_timing (&info [i], last_major_num_sections, last_los_memory_usage);
 199         }
 200         last_major_num_sections = major_collector.get_num_major_sections ();
 201 }
 202
 203 /*
 204 Global GC memory tracking.
 205 This tracks the total usage of memory by the GC. This includes
 206 managed and unmanaged memory.
 207 */
 208
 209 static unsigned long
 210 prot_flags_for_activate (int activate)
 211 {
 212         unsigned long prot_flags = activate? MONO_MMAP_READ|MONO_MMAP_WRITE: MONO_MMAP_NONE;
 213         return prot_flags | MONO_MMAP_PRIVATE | MONO_MMAP_ANON;
 214 }
 215
 216 void
 217 sgen_assert_memory_alloc (void *ptr, size_t requested_size, const char *assert_description)
 218 {
 219         if (ptr || !assert_description)
 220                 return;
 221         fprintf (stderr, "Error: Garbage collector could not allocate %zu bytes of memory for %s.\n", requested_size, assert_description);
 222         exit (1);
 223 }
 224
 225 /*
 226  * Allocate a big chunk of memory from the OS (usually 64KB to several megabytes).
 227  * This must not require any lock.
 228  */
 229 void*
 230 sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char *assert_description)
 231 {
 232         void *ptr;
 233
 234         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 235
 236         ptr = mono_valloc (0, size, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 237         sgen_assert_memory_alloc (ptr, size, assert_description);
 238         if (ptr) {
 239                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 240                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 241         }
 242         return ptr;
 243 }
 244
 245 /* size must be a power of 2 */
 246 void*
 247 sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char *assert_description)
 248 {
 249         void *ptr;
 250
 251         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 252
 253         ptr = mono_valloc_aligned (size, alignment, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 254         sgen_assert_memory_alloc (ptr, size, assert_description);
 255         if (ptr) {
 256                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 257                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 258         }
 259         return ptr;
 260 }
 261
 262 /*
 263  * Free the memory returned by sgen_alloc_os_memory (), returning it to the OS.
 264  */
 265 void
 266 sgen_free_os_memory (void *addr, size_t size, SgenAllocFlags flags)
 267 {
 268         g_assert (!(flags & ~SGEN_ALLOC_HEAP));
 269
 270         mono_vfree (addr, size);
 271         SGEN_ATOMIC_ADD_P (total_alloc, -(gssize)size);
 272         total_alloc_max = MAX (total_alloc_max, total_alloc);
 273 }
 274
 275 size_t
 276 sgen_gc_get_total_heap_allocation (void)
 277 {
 278         return total_alloc;
 279 }
 280
 281
 282 /*
 283 Heap Sizing limits.
 284 This limit the max size of the heap. It takes into account
 285 only memory actively in use to hold heap objects and not
 286 for other parts of the GC.
 287  */
 288 static mword
 289 sgen_memgov_available_free_space (void)
 290 {
 291         return max_heap_size - MIN (allocated_heap, max_heap_size);
 292 }
 293
 294 void
 295 sgen_memgov_release_space (mword size, int space)
 296 {
 297         SGEN_ATOMIC_ADD_P (allocated_heap, -(gssize)size);
 298 }
 299
 300 gboolean
 301 sgen_memgov_try_alloc_space (mword size, int space)
 302 {
 303         if (sgen_memgov_available_free_space () < size) {
 304                 SGEN_ASSERT (4, !sgen_thread_pool_is_thread_pool_thread (mono_native_thread_id_get ()), "Memory shouldn't run out in worker thread");
 305                 return FALSE;
 306         }
 307
 308         SGEN_ATOMIC_ADD_P (allocated_heap, size);
 309         sgen_client_total_allocated_heap_changed (allocated_heap);
 310         return TRUE;
 311 }
 312
 313 void
 314 sgen_memgov_init (size_t max_heap, size_t soft_limit, gboolean debug_allowance, double allowance_ratio, double save_target)
 315 {
 316         if (soft_limit)
 317                 soft_heap_limit = soft_limit;
 318
 319         debug_print_allowance = debug_allowance;
 320         major_collection_trigger_size = MIN_MINOR_COLLECTION_ALLOWANCE;
 321
 322         mono_counters_register ("Memgov alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_VARIABLE, &total_alloc);
 323         mono_counters_register ("Memgov max alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_MONOTONIC, &total_alloc_max);
 324
 325         if (max_heap == 0)
 326                 return;
 327
 328         if (max_heap < soft_limit) {
 329                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Setting to minimum.", "`max-heap-size` must be at least as large as `soft-heap-limit`.");
 330                 max_heap = soft_limit;
 331         }
 332
 333         if (max_heap < sgen_nursery_size * 4) {
 334                 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`.");
 335                 max_heap = sgen_nursery_size * 4;
 336         }
 337         max_heap_size = max_heap - sgen_nursery_size;
 338
 339         if (allowance_ratio)
 340                 default_allowance_nursery_size_ratio = allowance_ratio;
 341
 342         if (save_target)
 343                 save_target_ratio = save_target;
 344 }
 345
 346 #endif