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 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         last_major_num_sections = major_collector.get_num_major_sections ();
 182 }
 183
 184 /*
 185 Global GC memory tracking.
 186 This tracks the total usage of memory by the GC. This includes
 187 managed and unmanaged memory.
 188 */
 189
 190 static unsigned long
 191 prot_flags_for_activate (int activate)
 192 {
 193         unsigned long prot_flags = activate? MONO_MMAP_READ|MONO_MMAP_WRITE: MONO_MMAP_NONE;
 194         return prot_flags | MONO_MMAP_PRIVATE | MONO_MMAP_ANON;
 195 }
 196
 197 void
 198 sgen_assert_memory_alloc (void *ptr, size_t requested_size, const char *assert_description)
 199 {
 200         if (ptr || !assert_description)
 201                 return;
 202         fprintf (stderr, "Error: Garbage collector could not allocate %zu bytes of memory for %s.\n", requested_size, assert_description);
 203         exit (1);
 204 }
 205
 206 /*
 207  * Allocate a big chunk of memory from the OS (usually 64KB to several megabytes).
 208  * This must not require any lock.
 209  */
 210 void*
 211 sgen_alloc_os_memory (size_t size, SgenAllocFlags flags, const char *assert_description)
 212 {
 213         void *ptr;
 214
 215         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 216
 217         ptr = mono_valloc (0, size, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 218         sgen_assert_memory_alloc (ptr, size, assert_description);
 219         if (ptr) {
 220                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 221                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 222         }
 223         return ptr;
 224 }
 225
 226 /* size must be a power of 2 */
 227 void*
 228 sgen_alloc_os_memory_aligned (size_t size, mword alignment, SgenAllocFlags flags, const char *assert_description)
 229 {
 230         void *ptr;
 231
 232         g_assert (!(flags & ~(SGEN_ALLOC_HEAP | SGEN_ALLOC_ACTIVATE)));
 233
 234         ptr = mono_valloc_aligned (size, alignment, prot_flags_for_activate (flags & SGEN_ALLOC_ACTIVATE));
 235         sgen_assert_memory_alloc (ptr, size, assert_description);
 236         if (ptr) {
 237                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 238                 total_alloc_max = MAX (total_alloc_max, total_alloc);
 239         }
 240         return ptr;
 241 }
 242
 243 /*
 244  * Free the memory returned by sgen_alloc_os_memory (), returning it to the OS.
 245  */
 246 void
 247 sgen_free_os_memory (void *addr, size_t size, SgenAllocFlags flags)
 248 {
 249         g_assert (!(flags & ~SGEN_ALLOC_HEAP));
 250
 251         mono_vfree (addr, size);
 252         SGEN_ATOMIC_ADD_P (total_alloc, -(gssize)size);
 253         total_alloc_max = MAX (total_alloc_max, total_alloc);
 254 }
 255
 256 size_t
 257 sgen_gc_get_total_heap_allocation (void)
 258 {
 259         return total_alloc;
 260 }
 261
 262
 263 /*
 264 Heap Sizing limits.
 265 This limit the max size of the heap. It takes into account
 266 only memory actively in use to hold heap objects and not
 267 for other parts of the GC.
 268  */
 269 static mword
 270 sgen_memgov_available_free_space (void)
 271 {
 272         return max_heap_size - MIN (allocated_heap, max_heap_size);
 273 }
 274
 275 void
 276 sgen_memgov_release_space (mword size, int space)
 277 {
 278         SGEN_ATOMIC_ADD_P (allocated_heap, -(gssize)size);
 279 }
 280
 281 gboolean
 282 sgen_memgov_try_alloc_space (mword size, int space)
 283 {
 284         if (sgen_memgov_available_free_space () < size) {
 285                 SGEN_ASSERT (4, !sgen_thread_pool_is_thread_pool_thread (mono_native_thread_id_get ()), "Memory shouldn't run out in worker thread");
 286                 return FALSE;
 287         }
 288
 289         SGEN_ATOMIC_ADD_P (allocated_heap, size);
 290         sgen_client_total_allocated_heap_changed (allocated_heap);
 291         return TRUE;
 292 }
 293
 294 void
 295 sgen_memgov_init (size_t max_heap, size_t soft_limit, gboolean debug_allowance, double allowance_ratio, double save_target)
 296 {
 297         if (soft_limit)
 298                 soft_heap_limit = soft_limit;
 299
 300         debug_print_allowance = debug_allowance;
 301         major_collection_trigger_size = MIN_MINOR_COLLECTION_ALLOWANCE;
 302
 303         mono_counters_register ("Memgov alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_VARIABLE, &total_alloc);
 304         mono_counters_register ("Memgov max alloc", MONO_COUNTER_GC | MONO_COUNTER_WORD | MONO_COUNTER_BYTES | MONO_COUNTER_MONOTONIC, &total_alloc_max);
 305
 306         if (max_heap == 0)
 307                 return;
 308
 309         if (max_heap < soft_limit) {
 310                 sgen_env_var_error (MONO_GC_PARAMS_NAME, "Setting to minimum.", "`max-heap-size` must be at least as large as `soft-heap-limit`.");
 311                 max_heap = soft_limit;
 312         }
 313
 314         if (max_heap < sgen_nursery_size * 4) {
 315                 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`.");
 316                 max_heap = sgen_nursery_size * 4;
 317         }
 318         max_heap_size = max_heap - sgen_nursery_size;
 319
 320         if (allowance_ratio)
 321                 default_allowance_nursery_size_ratio = allowance_ratio;
 322
 323         if (save_target)
 324                 save_target_ratio = save_target;
 325 }
 326
 327 #endif