mono/metadata/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 "metadata/sgen-gc.h"
  31 #include "metadata/sgen-memory-governor.h"
  32 #include "metadata/sgen-thread-pool.h"
  33 #include "metadata/mono-gc.h"
  34
  35 #include "utils/mono-counters.h"
  36 #include "utils/mono-mmap.h"
  37 #include "utils/mono-logger-internal.h"
  38
  39 #define MIN_MINOR_COLLECTION_ALLOWANCE  ((mword)(DEFAULT_NURSERY_SIZE * default_allowance_nursery_size_ratio))
  40
  41 /*Heap limits and allocation knobs*/
  42 static mword max_heap_size = ((mword)0)- ((mword)1);
  43 static mword soft_heap_limit = ((mword)0) - ((mword)1);
  44
  45 static double default_allowance_nursery_size_ratio = SGEN_DEFAULT_ALLOWANCE_NURSERY_SIZE_RATIO;
  46 static double save_target_ratio = SGEN_DEFAULT_SAVE_TARGET_RATIO;
  47
  48 /**/
  49 static mword allocated_heap;
  50 static mword total_alloc = 0;
  51 static mword total_alloc_max = 0;
  52
  53 /* GC triggers. */
  54
  55 static gboolean debug_print_allowance = FALSE;
  56
  57
  58 /* use this to tune when to do a major/minor collection */
  59 static mword memory_pressure = 0;
  60 static mword major_collection_trigger_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
  80         if (!need_calculate_minor_collection_allowance)
  81                 return;
  82
  83         SGEN_ASSERT (0, major_collector.have_swept (), "Can only calculate allowance if heap is swept");
  84
  85         new_major = major_collector.get_bytes_survived_last_sweep ();
  86         new_heap_size = new_major + last_collection_los_memory_usage;
  87
  88         /*
  89          * We allow the heap to grow by one third its current size before we start the next
  90          * major collection.
  91          */
  92         allowance_target = new_heap_size / 3;
  93
  94         allowance = MAX (allowance_target, MIN_MINOR_COLLECTION_ALLOWANCE);
  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 gboolean
 119 sgen_need_major_collection (mword space_needed)
 120 {
 121         size_t heap_size;
 122
 123         if (sgen_concurrent_collection_in_progress ())
 124                 return FALSE;
 125
 126         /* FIXME: This is a cop-out.  We should have some way of figuring this out. */
 127         if (!major_collector.have_swept ())
 128                 return FALSE;
 129
 130         if (space_needed > sgen_memgov_available_free_space ())
 131                 return TRUE;
 132
 133         sgen_memgov_calculate_minor_collection_allowance ();
 134
 135         heap_size = major_collector.get_num_major_sections () * major_collector.section_size + los_memory_usage;
 136
 137         return heap_size > major_collection_trigger_size;
 138 }
 139
 140 void
 141 sgen_memgov_minor_collection_start (void)
 142 {
 143 }
 144
 145 void
 146 sgen_memgov_minor_collection_end (void)
 147 {
 148 }
 149
 150 void
 151 sgen_memgov_major_collection_start (void)
 152 {
 153         need_calculate_minor_collection_allowance = TRUE;
 154
 155         if (debug_print_allowance) {
 156                 SGEN_LOG (0, "Starting collection with heap size %ld bytes", (long)(major_collector.get_num_major_sections () * major_collector.section_size + los_memory_usage));
 157         }
 158 }
 159
 160 void
 161 sgen_memgov_major_collection_end (gboolean forced)
 162 {
 163         last_collection_los_memory_usage = los_memory_usage;
 164
 165         if (forced) {
 166                 sgen_get_major_collector ()->finish_sweeping ();
 167                 sgen_memgov_calculate_minor_collection_allowance ();
 168         }
 169 }
 170
 171 static void
 172 log_timming (GGTimingInfo *info)
 173 {
 174         //unsigned long stw_time, unsigned long bridge_time, gboolean is_overflow
 175         mword num_major_sections = major_collector.get_num_major_sections ();
 176         char full_timing_buff [1024];
 177         full_timing_buff [0] = '\0';
 178
 179         if (!info->is_overflow)
 180                 sprintf (full_timing_buff, "total %.2fms, bridge %.2fms", info->stw_time / 10000.0f, (int)info->bridge_time / 10000.0f);
 181         if (info->generation == GENERATION_OLD)
 182                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "GC_MAJOR%s: (%s) pause %.2fms, %s major %dK/%dK los %dK/%dK",
 183                         info->is_overflow ? "_OVERFLOW" : "",
 184                         info->reason ? info->reason : "",
 185                         (int)info->total_time / 10000.0f,
 186                         full_timing_buff,
 187                         major_collector.section_size * num_major_sections / 1024,
 188                         major_collector.section_size * last_major_num_sections / 1024,
 189                         los_memory_usage / 1024,
 190                         last_los_memory_usage / 1024);
 191         else
 192                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "GC_MINOR%s: (%s) pause %.2fms, %s promoted %dK major %dK los %dK",
 193                                 info->is_overflow ? "_OVERFLOW" : "",
 194                         info->reason ? info->reason : "",
 195                         (int)info->total_time / 10000.0f,
 196                         full_timing_buff,
 197                         (num_major_sections - last_major_num_sections) * major_collector.section_size / 1024,
 198                         major_collector.section_size * num_major_sections / 1024,
 199                         los_memory_usage / 1024);
 200 }
 201
 202 /* FIXME: Remove either these or the specialized ones above. */
 203 void
 204 sgen_memgov_collection_start (int generation)
 205 {
 206 }
 207
 208 void
 209 sgen_memgov_collection_end (int generation, GGTimingInfo* info, int info_count)
 210 {
 211         int i;
 212         for (i = 0; i < info_count; ++i) {
 213                 if (info[i].generation != -1)
 214                         log_timming (&info [i]);
 215         }
 216 }
 217
 218 /* Memory pressure API */
 219
 220 /* Negative value to remove */
 221 void
 222 mono_gc_add_memory_pressure (gint64 value)
 223 {
 224         /* FIXME: Use interlocked functions */
 225         LOCK_GC;
 226         memory_pressure += value;
 227         UNLOCK_GC;
 228 }
 229
 230
 231 /*
 232 Global GC memory tracking.
 233 This tracks the total usage of memory by the GC. This includes
 234 managed and unmanaged memory.
 235 */
 236
 237 static unsigned long
 238 prot_flags_for_activate (int activate)
 239 {
 240         unsigned long prot_flags = activate? MONO_MMAP_READ|MONO_MMAP_WRITE: MONO_MMAP_NONE;
 241         return prot_flags | MONO_MMAP_PRIVATE | MONO_MMAP_ANON;
 242 }
 243
 244 void
 245 sgen_assert_memory_alloc (void *ptr, size_t requested_size, const char *assert_description)
 246 {
 247         if (ptr || !assert_description)
 248                 return;
 249         fprintf (stderr, "Error: Garbage collector could not allocate %zu bytes of memory for %s.\n", requested_size, assert_description);
 250         exit (1);
 251 }
 252
 253 /*
 254  * Allocate a big chunk of memory from the OS (usually 64KB to several megabytes).
 255  * This must not require any lock.
 256  */
 257 void*
 258 sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char *assert_description)
 259 {
 260         void *ptr;
 261
 262         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 263
 264         ptr = mono_valloc (0, size, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 265         sgen_assert_memory_alloc (ptr, size, assert_description);
 266         if (ptr) {
 267                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 268                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 269         }
 270         return ptr;
 271 }
 272
 273 /* size must be a power of 2 */
 274 void*
 275 sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char *assert_description)
 276 {
 277         void *ptr;
 278
 279         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 280
 281         ptr = mono_valloc_aligned (size, alignment, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 282         sgen_assert_memory_alloc (ptr, size, assert_description);
 283         if (ptr) {
 284                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 285                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 286         }
 287         return ptr;
 288 }
 289
 290 /*
 291  * Free the memory returned by sgen_alloc_os_memory (), returning it to the OS.
 292  */
 293 void
 294 sgen_free_os_memory (void *addr, size_t size, SgenAllocFlags flags)
 295 {
 296         g_assert (!(flags & ~SGEN_ALLOC_HEAP));
 297
 298         mono_vfree (addr, size);
 299         SGEN_ATOMIC_ADD_P (total_alloc, -(gssize)size);
 300         total_alloc_max = MAX (total_alloc_max, total_alloc);
 301 }
 302
 303 int64_t
 304 mono_gc_get_heap_size (void)
 305 {
 306         return total_alloc;
 307 }
 308
 309
 310 /*
 311 Heap Sizing limits.
 312 This limit the max size of the heap. It takes into account
 313 only memory actively in use to hold heap objects and not
 314 for other parts of the GC.
 315  */
 316 static mword
 317 sgen_memgov_available_free_space (void)
 318 {
 319         return max_heap_size - MIN (allocated_heap, max_heap_size);
 320 }
 321
 322 void
 323 sgen_memgov_release_space (mword size, int space)
 324 {
 325         SGEN_ATOMIC_ADD_P (allocated_heap, -(gssize)size);
 326 }
 327
 328 gboolean
 329 sgen_memgov_try_alloc_space (mword size, int space)
 330 {
 331         if (sgen_memgov_available_free_space () < size) {
 332                 SGEN_ASSERT (4, !sgen_thread_pool_is_thread_pool_thread (mono_native_thread_id_get ()), "Memory shouldn't run out in worker thread");
 333                 return FALSE;
 334         }
 335
 336         SGEN_ATOMIC_ADD_P (allocated_heap, size);
 337         mono_runtime_resource_check_limit (MONO_RESOURCE_GC_HEAP, allocated_heap);
 338         return TRUE;
 339 }
 340
 341 void
 342 sgen_memgov_init (size_t max_heap, size_t soft_limit, gboolean debug_allowance, double allowance_ratio, double save_target)
 343 {
 344         if (soft_limit)
 345                 soft_heap_limit = soft_limit;
 346
 347         debug_print_allowance = debug_allowance;
 348         major_collection_trigger_size = MIN_MINOR_COLLECTION_ALLOWANCE;
 349
 350         mono_counters_register ("Memgov alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_VARIABLE, &total_alloc);
 351         mono_counters_register ("Memgov max alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_MONOTONIC, &total_alloc_max);
 352
 353         if (max_heap == 0)
 354                 return;
 355
 356         if (max_heap < soft_limit) {
 357                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Setting to minimum.", "`max-heap-size` must be at least as large as `soft-heap-limit`.");
 358                 max_heap = soft_limit;
 359         }
 360
 361         if (max_heap < sgen_nursery_size * 4) {
 362                 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`.");
 363                 max_heap = sgen_nursery_size * 4;
 364         }
 365         max_heap_size = max_heap - sgen_nursery_size;
 366
 367         if (allowance_ratio)
 368                 default_allowance_nursery_size_ratio = allowance_ratio;
 369
 370         if (save_target)
 371                 save_target_ratio = save_target;
 372 }
 373
 374 #endif