mono/metadata/sgen-memory-governor.c

   1 /*
   2  * sgen-cardtable.c: Card table implementation for sgen
   3  *
   4  * Author:
   5  *      Rodrigo Kumpera (rkumpera@novell.com)
   6  *
   7  * SGen is licensed under the terms of the MIT X11 license
   8  *
   9  * Copyright 2001-2003 Ximian, Inc
  10  * Copyright 2003-2010 Novell, Inc.
  11  * Copyright 2011 Xamarin Inc (http://www.xamarin.com)
  12  *
  13  * Permission is hereby granted, free of charge, to any person obtaining
  14  * a copy of this software and associated documentation files (the
  15  * "Software"), to deal in the Software without restriction, including
  16  * without limitation the rights to use, copy, modify, merge, publish,
  17  * distribute, sublicense, and/or sell copies of the Software, and to
  18  * permit persons to whom the Software is furnished to do so, subject to
  19  * the following conditions:
  20  *
  21  * The above copyright notice and this permission notice shall be
  22  * included in all copies or substantial portions of the Software.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  28  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  29  * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  30  * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  31  */
  32
  33 #include "config.h"
  34 #ifdef HAVE_SGEN_GC
  35
  36 #include "metadata/sgen-gc.h"
  37 #include "metadata/sgen-memory-governor.h"
  38 #include "metadata/mono-gc.h"
  39
  40 #include "utils/mono-counters.h"
  41 #include "utils/mono-mmap.h"
  42 #include "utils/mono-logger-internal.h"
  43
  44 #define MIN_MINOR_COLLECTION_ALLOWANCE  ((mword)(DEFAULT_NURSERY_SIZE * default_allowance_nursery_size_ratio))
  45
  46 /*Heap limits and allocation knobs*/
  47 static mword max_heap_size = ((mword)0)- ((mword)1);
  48 static mword soft_heap_limit = ((mword)0) - ((mword)1);
  49
  50 static double default_allowance_nursery_size_ratio = SGEN_DEFAULT_ALLOWANCE_NURSERY_SIZE_RATIO;
  51 static double save_target_ratio = SGEN_DEFAULT_SAVE_TARGET_RATIO;
  52
  53 /**/
  54 static mword allocated_heap;
  55 static mword total_alloc = 0;
  56
  57 /* GC triggers. */
  58
  59 static gboolean debug_print_allowance = FALSE;
  60
  61
  62 /* use this to tune when to do a major/minor collection */
  63 static mword memory_pressure = 0;
  64 static mword minor_collection_allowance;
  65 static int minor_collection_sections_alloced = 0;
  66
  67 static int last_major_num_sections = 0;
  68 static int last_los_memory_usage = 0;
  69
  70 static gboolean need_calculate_minor_collection_allowance;
  71
  72 static int last_collection_old_num_major_sections;
  73 static mword last_collection_los_memory_usage = 0;
  74 static mword last_collection_old_los_memory_usage;
  75 static mword last_collection_los_memory_alloced;
  76
  77 static mword sgen_memgov_available_free_space (void);
  78
  79
  80 static mword
  81 double_to_mword_with_saturation (double value)
  82 {
  83         if (value >= (double)MWORD_MAX_VALUE)
  84                 return MWORD_MAX_VALUE;
  85         return (mword)value;
  86 }
  87
  88 /* GC trigger heuristics. */
  89
  90 static void
  91 sgen_memgov_try_calculate_minor_collection_allowance (gboolean overwrite)
  92 {
  93         int num_major_sections, num_major_sections_saved;
  94         mword los_memory_saved, new_major, new_heap_size, save_target, allowance_target;
  95
  96         if (overwrite)
  97                 g_assert (need_calculate_minor_collection_allowance);
  98
  99         if (!need_calculate_minor_collection_allowance)
 100                 return;
 101
 102         if (!*major_collector.have_swept) {
 103                 if (overwrite)
 104                         minor_collection_allowance = MIN_MINOR_COLLECTION_ALLOWANCE;
 105                 return;
 106         }
 107
 108         num_major_sections = major_collector.get_num_major_sections ();
 109
 110         num_major_sections_saved = MAX (last_collection_old_num_major_sections - num_major_sections, 0);
 111         los_memory_saved = MAX (last_collection_old_los_memory_usage - last_collection_los_memory_usage, 1);
 112
 113         new_major = num_major_sections * major_collector.section_size;
 114         new_heap_size = new_major + last_collection_los_memory_usage;
 115
 116         save_target = (mword)((new_major + last_collection_los_memory_usage) * SGEN_DEFAULT_SAVE_TARGET_RATIO);
 117
 118         /*
 119          * We aim to allow the allocation of as many sections as is
 120          * necessary to reclaim save_target sections in the next
 121          * collection.  We assume the collection pattern won't change.
 122          * In the last cycle, we had num_major_sections_saved for
 123          * minor_collection_sections_alloced.  Assuming things won't
 124          * change, this must be the same ratio as save_target for
 125          * allowance_target, i.e.
 126          *
 127          *    num_major_sections_saved            save_target
 128          * --------------------------------- == ----------------
 129          * minor_collection_sections_alloced    allowance_target
 130          *
 131          * hence:
 132          */
 133         allowance_target = double_to_mword_with_saturation ((double)save_target * (double)(minor_collection_sections_alloced * major_collector.section_size + last_collection_los_memory_alloced) / (double)(num_major_sections_saved * major_collector.section_size + los_memory_saved));
 134
 135         minor_collection_allowance = MAX (MIN (allowance_target, num_major_sections * major_collector.section_size + los_memory_usage), MIN_MINOR_COLLECTION_ALLOWANCE);
 136
 137         if (new_heap_size + minor_collection_allowance > soft_heap_limit) {
 138                 if (new_heap_size > soft_heap_limit)
 139                         minor_collection_allowance = MIN_MINOR_COLLECTION_ALLOWANCE;
 140                 else
 141                         minor_collection_allowance = MAX (soft_heap_limit - new_heap_size, MIN_MINOR_COLLECTION_ALLOWANCE);
 142         }
 143
 144         if (debug_print_allowance) {
 145                 mword old_major = last_collection_old_num_major_sections * major_collector.section_size;
 146
 147                 fprintf (gc_debug_file, "Before collection: %td bytes (%td major, %td LOS)\n",
 148                                 old_major + last_collection_old_los_memory_usage, old_major, last_collection_old_los_memory_usage);
 149                 fprintf (gc_debug_file, "After collection: %td bytes (%td major, %td LOS)\n",
 150                                 new_heap_size, new_major, last_collection_los_memory_usage);
 151                 fprintf (gc_debug_file, "Allowance: %td bytes\n", minor_collection_allowance);
 152         }
 153
 154         if (major_collector.have_computed_minor_collection_allowance)
 155                 major_collector.have_computed_minor_collection_allowance ();
 156
 157         need_calculate_minor_collection_allowance = FALSE;
 158 }
 159
 160
 161 gboolean
 162 sgen_need_major_collection (mword space_needed)
 163 {
 164         mword los_alloced = los_memory_usage - MIN (last_collection_los_memory_usage, los_memory_usage);
 165         return (space_needed > sgen_memgov_available_free_space ()) ||
 166                 minor_collection_sections_alloced * major_collector.section_size + los_alloced > minor_collection_allowance;
 167 }
 168
 169 void
 170 sgen_memgov_minor_collection_start (void)
 171 {
 172         sgen_memgov_try_calculate_minor_collection_allowance (FALSE);
 173 }
 174
 175 void
 176 sgen_memgov_minor_collection_end (void)
 177 {
 178 }
 179
 180 void
 181 sgen_memgov_major_collection_start (void)
 182 {
 183         last_collection_old_num_major_sections = sgen_get_major_collector ()->get_num_major_sections ();
 184
 185         /*
 186          * A domain could have been freed, resulting in
 187          * los_memory_usage being less than last_collection_los_memory_usage.
 188          */
 189         last_collection_los_memory_alloced = los_memory_usage - MIN (last_collection_los_memory_usage, los_memory_usage);
 190         last_collection_old_los_memory_usage = los_memory_usage;
 191
 192         need_calculate_minor_collection_allowance = TRUE;
 193 }
 194
 195 void
 196 sgen_memgov_major_collection_end (void)
 197 {
 198         sgen_memgov_try_calculate_minor_collection_allowance (TRUE);
 199
 200         minor_collection_sections_alloced = 0;
 201         last_collection_los_memory_usage = los_memory_usage;
 202 }
 203
 204 void
 205 sgen_memgov_collection_start (int generation)
 206 {
 207         last_major_num_sections = major_collector.get_num_major_sections ();
 208         last_los_memory_usage = los_memory_usage;
 209 }
 210
 211 static void
 212 log_timming (GGTimingInfo *info)
 213 {
 214         //unsigned long stw_time, unsigned long bridge_time, gboolean is_overflow
 215         int num_major_sections = major_collector.get_num_major_sections ();
 216         char full_timing_buff [1024];
 217         full_timing_buff [0] = '\0';
 218
 219         if (!info->is_overflow)
 220                 sprintf (full_timing_buff, "total %.2fms, bridge %.2f", info->stw_time / 1000.0f, (int)info->bridge_time / 1000.0f);
 221         if (info->generation == GENERATION_OLD)
 222                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "GC_MAJOR%s: (%s) pause %.2fms, %s major %dK/%dK los %dK/%dK",
 223                         info->is_overflow ? "_OVERFLOW" : "",
 224                         info->reason,
 225                         (int)info->total_time / 1000.0f,
 226                         full_timing_buff,
 227                         major_collector.section_size * num_major_sections / 1024,
 228                         major_collector.section_size * last_major_num_sections / 1024,
 229                         los_memory_usage / 1024,
 230                         last_los_memory_usage / 1024);
 231         else
 232                 mono_trace (G_LOG_LEVEL_INFO, MONO_TRACE_GC, "GC_MINOR%s: (%s) pause %.2fms, %s promoted %dK major %dK los %dK",
 233                                 info->is_overflow ? "_OVERFLOW" : "",
 234                         info->reason,
 235                         (int)info->total_time / 1000.0f,
 236                         full_timing_buff,
 237                         (num_major_sections - last_major_num_sections) * major_collector.section_size / 1024,
 238                         major_collector.section_size * num_major_sections / 1024,
 239                         los_memory_usage / 1024);
 240 }
 241
 242 void
 243 sgen_memgov_collection_end (int generation, GGTimingInfo* info, int info_count)
 244 {
 245         int i;
 246         for (i = 0; i < info_count; ++i) {
 247                 if (info->generation != -1)
 248                         log_timming (&info [i]);
 249         }
 250 }
 251
 252 void
 253 sgen_register_major_sections_alloced (int num_sections)
 254 {
 255         minor_collection_sections_alloced += num_sections;
 256 }
 257
 258 mword
 259 sgen_get_minor_collection_allowance (void)
 260 {
 261         return minor_collection_allowance;
 262 }
 263
 264 /* Memory pressure API */
 265
 266 /* Negative value to remove */
 267 void
 268 mono_gc_add_memory_pressure (gint64 value)
 269 {
 270         /* FIXME: Use interlocked functions */
 271         LOCK_GC;
 272         memory_pressure += value;
 273         UNLOCK_GC;
 274 }
 275
 276
 277 /*
 278 Global GC memory tracking.
 279 This tracks the total usage of memory by the GC. This includes
 280 managed and unmanaged memory.
 281 */
 282
 283 static unsigned long
 284 prot_flags_for_activate (int activate)
 285 {
 286         unsigned long prot_flags = activate? MONO_MMAP_READ|MONO_MMAP_WRITE: MONO_MMAP_NONE;
 287         return prot_flags | MONO_MMAP_PRIVATE | MONO_MMAP_ANON;
 288 }
 289
 290 /*
 291  * Allocate a big chunk of memory from the OS (usually 64KB to several megabytes).
 292  * This must not require any lock.
 293  */
 294 void*
 295 sgen_alloc_os_memory (size_t size, int activate)
 296 {
 297         void *ptr = mono_valloc (0, size, prot_flags_for_activate (activate));
 298         if (ptr)
 299                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 300         return ptr;
 301 }
 302
 303 /* size must be a power of 2 */
 304 void*
 305 sgen_alloc_os_memory_aligned (size_t size, mword alignment, gboolean activate)
 306 {
 307         void *ptr = mono_valloc_aligned (size, alignment, prot_flags_for_activate (activate));
 308         if (ptr)
 309                 SGEN_ATOMIC_ADD_P (total_alloc, size);
 310         return ptr;
 311 }
 312
 313 /*
 314  * Free the memory returned by sgen_alloc_os_memory (), returning it to the OS.
 315  */
 316 void
 317 sgen_free_os_memory (void *addr, size_t size)
 318 {
 319         mono_vfree (addr, size);
 320         SGEN_ATOMIC_ADD_P (total_alloc, -size);
 321 }
 322
 323 int64_t
 324 mono_gc_get_heap_size (void)
 325 {
 326         return total_alloc;
 327 }
 328
 329
 330 /*
 331 Heap Sizing limits.
 332 This limit the max size of the heap. It takes into account
 333 only memory actively in use to hold heap objects and not
 334 for other parts of the GC.
 335  */
 336 static mword
 337 sgen_memgov_available_free_space (void)
 338 {
 339         return max_heap_size - MIN (allocated_heap, max_heap_size);
 340 }
 341
 342 void
 343 sgen_memgov_release_space (mword size, int space)
 344 {
 345         SGEN_ATOMIC_ADD_P (allocated_heap, -size);
 346 }
 347
 348 gboolean
 349 sgen_memgov_try_alloc_space (mword size, int space)
 350 {
 351         if (sgen_memgov_available_free_space () < size)
 352                 return FALSE;
 353
 354         SGEN_ATOMIC_ADD_P (allocated_heap, size);
 355         mono_runtime_resource_check_limit (MONO_RESOURCE_GC_HEAP, allocated_heap);
 356         return TRUE;
 357 }
 358
 359 void
 360 sgen_memgov_init (glong max_heap, glong soft_limit, gboolean debug_allowance, double allowance_ratio, double save_target)
 361 {
 362         if (soft_limit)
 363                 soft_heap_limit = soft_limit;
 364
 365         debug_print_allowance = debug_allowance;
 366
 367         if (max_heap == 0)
 368                 return;
 369
 370         if (max_heap < soft_limit) {
 371                 fprintf (stderr, "max-heap-size must be at least as large as soft-heap-limit.\n");
 372                 exit (1);
 373         }
 374
 375         if (max_heap < sgen_nursery_size * 4) {
 376                 fprintf (stderr, "max-heap-size must be at least 4 times larger than nursery size.\n");
 377                 exit (1);
 378         }
 379         max_heap_size = max_heap - sgen_nursery_size;
 380
 381         minor_collection_allowance = MIN_MINOR_COLLECTION_ALLOWANCE;
 382
 383         if (allowance_ratio)
 384                 default_allowance_nursery_size_ratio = allowance_ratio;
 385
 386         if (save_target)
 387                 save_target_ratio = save_target;
 388 }
 389
 390 #endif