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 / 3;
  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 gboolean
 116 sgen_need_major_collection (mword space_needed)
 117 {
 118         size_t heap_size;
 119
 120         if (sgen_concurrent_collection_in_progress ())
 121                 return FALSE;
 122
 123         /* FIXME: This is a cop-out.  We should have some way of figuring this out. */
 124         if (!major_collector.have_swept ())
 125                 return FALSE;
 126
 127         if (space_needed > sgen_memgov_available_free_space ())
 128                 return TRUE;
 129
 130         sgen_memgov_calculate_minor_collection_allowance ();
 131
 132         heap_size = major_collector.get_num_major_sections () * major_collector.section_size + los_memory_usage;
 133
 134         return heap_size > major_collection_trigger_size;
 135 }
 136
 137 void
 138 sgen_memgov_minor_collection_start (void)
 139 {
 140 }
 141
 142 void
 143 sgen_memgov_minor_collection_end (void)
 144 {
 145 }
 146
 147 void
 148 sgen_memgov_major_collection_start (void)
 149 {
 150         need_calculate_minor_collection_allowance = TRUE;
 151
 152         if (debug_print_allowance) {
 153                 SGEN_LOG (0, "Starting collection with heap size %ld bytes", (long)(major_collector.get_num_major_sections () * major_collector.section_size + los_memory_usage));
 154         }
 155 }
 156
 157 void
 158 sgen_memgov_major_collection_end (gboolean forced)
 159 {
 160         last_collection_los_memory_usage = los_memory_usage;
 161
 162         if (forced) {
 163                 sgen_get_major_collector ()->finish_sweeping ();
 164                 sgen_memgov_calculate_minor_collection_allowance ();
 165         }
 166 }
 167
 168 void
 169 sgen_memgov_collection_start (int generation)
 170 {
 171 }
 172
 173 void
 174 sgen_memgov_collection_end (int generation, GGTimingInfo* info, int info_count)
 175 {
 176         int i;
 177         for (i = 0; i < info_count; ++i) {
 178                 if (info[i].generation != -1)
 179                         sgen_client_log_timing (&info [i], last_major_num_sections, last_los_memory_usage);
 180         }
 181 }
 182
 183 /*
 184 Global GC memory tracking.
 185 This tracks the total usage of memory by the GC. This includes
 186 managed and unmanaged memory.
 187 */
 188
 189 static unsigned long
 190 prot_flags_for_activate (int activate)
 191 {
 192         unsigned long prot_flags = activate? MONO_MMAP_READ|MONO_MMAP_WRITE: MONO_MMAP_NONE;
 193         return prot_flags | MONO_MMAP_PRIVATE | MONO_MMAP_ANON;
 194 }
 195
 196 void
 197 sgen_assert_memory_alloc (void *ptr, size_t requested_size, const char *assert_description)
 198 {
 199         if (ptr || !assert_description)
 200                 return;
 201         fprintf (stderr, "Error: Garbage collector could not allocate %zu bytes of memory for %s.\n", requested_size, assert_description);
 202         exit (1);
 203 }
 204
 205 /*
 206  * Allocate a big chunk of memory from the OS (usually 64KB to several megabytes).
 207  * This must not require any lock.
 208  */
 209 void*
 210 sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char *assert_description)
 211 {
 212         void *ptr;
 213
 214         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 215
 216         ptr = mono_valloc (0, size, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 217         sgen_assert_memory_alloc (ptr, size, assert_description);
 218         if (ptr) {
 219                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 220                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 221         }
 222         return ptr;
 223 }
 224
 225 /* size must be a power of 2 */
 226 void*
 227 sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char *assert_description)
 228 {
 229         void *ptr;
 230
 231         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 232
 233         ptr = mono_valloc_aligned (size, alignment, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 234         sgen_assert_memory_alloc (ptr, size, assert_description);
 235         if (ptr) {
 236                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 237                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 238         }
 239         return ptr;
 240 }
 241
 242 /*
 243  * Free the memory returned by sgen_alloc_os_memory (), returning it to the OS.
 244  */
 245 void
 246 sgen_free_os_memory (void *addr, size_t size, SgenAllocFlags flags)
 247 {
 248         g_assert (!(flags & ~SGEN_ALLOC_HEAP));
 249
 250         mono_vfree (addr, size);
 251         SGEN_ATOMIC_ADD_P (total_alloc, -(gssize)size);
 252         total_alloc_max = MAX (total_alloc_max, total_alloc);
 253 }
 254
 255 size_t
 256 sgen_gc_get_total_heap_allocation (void)
 257 {
 258         return total_alloc;
 259 }
 260
 261
 262 /*
 263 Heap Sizing limits.
 264 This limit the max size of the heap. It takes into account
 265 only memory actively in use to hold heap objects and not
 266 for other parts of the GC.
 267  */
 268 static mword
 269 sgen_memgov_available_free_space (void)
 270 {
 271         return max_heap_size - MIN (allocated_heap, max_heap_size);
 272 }
 273
 274 void
 275 sgen_memgov_release_space (mword size, int space)
 276 {
 277         SGEN_ATOMIC_ADD_P (allocated_heap, -(gssize)size);
 278 }
 279
 280 gboolean
 281 sgen_memgov_try_alloc_space (mword size, int space)
 282 {
 283         if (sgen_memgov_available_free_space () < size) {
 284                 SGEN_ASSERT (4, !sgen_thread_pool_is_thread_pool_thread (mono_native_thread_id_get ()), "Memory shouldn't run out in worker thread");
 285                 return FALSE;
 286         }
 287
 288         SGEN_ATOMIC_ADD_P (allocated_heap, size);
 289         sgen_client_total_allocated_heap_changed (allocated_heap);
 290         return TRUE;
 291 }
 292
 293 void
 294 sgen_memgov_init (size_t max_heap, size_t soft_limit, gboolean debug_allowance, double allowance_ratio, double save_target)
 295 {
 296         if (soft_limit)
 297                 soft_heap_limit = soft_limit;
 298
 299         debug_print_allowance = debug_allowance;
 300         major_collection_trigger_size = MIN_MINOR_COLLECTION_ALLOWANCE;
 301
 302         mono_counters_register ("Memgov alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_VARIABLE, &total_alloc);
 303         mono_counters_register ("Memgov max alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_MONOTONIC, &total_alloc_max);
 304
 305         if (max_heap == 0)
 306                 return;
 307
 308         if (max_heap < soft_limit) {
 309                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Setting to minimum.", "`max-heap-size` must be at least as large as `soft-heap-limit`.");
 310                 max_heap = soft_limit;
 311         }
 312
 313         if (max_heap < sgen_nursery_size * 4) {
 314                 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`.");
 315                 max_heap = sgen_nursery_size * 4;
 316         }
 317         max_heap_size = max_heap - sgen_nursery_size;
 318
 319         if (allowance_ratio)
 320                 default_allowance_nursery_size_ratio = allowance_ratio;
 321
 322         if (save_target)
 323                 save_target_ratio = save_target;
 324 }
 325
 326 #endif