[GC] Avoid OOM in large-allocation-only workloads (#105521)

A few problems can occur with workloads that only allocate huge objects:
- Regions can be pushed to the global decommit list faster than we can process them.  This can lead to OOM (more easily reproducible using a hard heap limit).
- BGCs don't currently call `distribute_free_regions`, so if only those occur, then the freelist processing never occurs at all.

This change addresses those by doing the following:
- Call `distribute_free_regions` during `background_mark_phase` (while we initially have the VM suspended to avoid complications).
- Currently, `distribute_free_regions` can't hit the `move_highest_free_regions` code path when `background_running_p()`.  Change that check to also require `settings.condemned_generation != max_generation`.
- Slow the movement of huge regions from the freelist to the global decommit list.
  - Add aging to regions in `global_free_huge_regions`.
  - Require an age of MIN_AGE_TO_DECOMMIT_HUGE (2) before including them in a surplus balance.
  - Factor aging code into `age_free_regions`.

Fixes #94175

Author: markples

src/coreclr/gc/gc.cpp

@@ -9651,7 +9651,7 @@ int gc_heap::grow_brick_card_tables (uint8_t* start,
         dprintf (GC_TABLE_LOG, ("card table: %zx(translated: %zx), seg map: %zx, mark array: %zx",
             (size_t)ct, (size_t)translated_ct, (size_t)new_seg_mapping_table, (size_t)card_table_mark_array (ct)));
 
-        if (hp->is_bgc_in_progress())
+        if (is_bgc_in_progress())
         {
             dprintf (GC_TABLE_LOG, ("new low: %p, new high: %p, latest mark array is %p(translate: %p)",
                                     saved_g_lowest_address, saved_g_highest_address,
@@ -9778,7 +9778,7 @@ int gc_heap::grow_brick_card_tables (uint8_t* start,
     else
     {
 #ifdef BACKGROUND_GC
-        if (hp->is_bgc_in_progress())
+        if (is_bgc_in_progress())
         {
             dprintf (GC_TABLE_LOG, ("in range new seg %p, mark_array is %p", new_seg, hp->mark_array));
             if (!commit_mark_array_new_seg (hp, new_seg))
@@ -13076,6 +13076,21 @@ void region_free_list::age_free_regions (region_free_list free_lists[count_free_
     }
 }
 
+size_t region_free_list::get_size_free_regions(int max_age)
+{
+    size_t result = 0;
+
+    for (heap_segment* region = head_free_region; region != nullptr; region = heap_segment_next (region))
+    {
+        if (heap_segment_age_in_free (region) <= max_age)
+        {
+            result += get_region_size(region);
+        }
+    }
+
+    return result;
+}
+
 void region_free_list::print (int hn, const char* msg, int* ages)
 {
     dprintf (3, ("h%2d PRINTING-------------------------------", hn));
@@ -13371,6 +13386,7 @@ void gc_heap::distribute_free_regions()
     global_free_huge_regions.transfer_regions (&global_regions_to_decommit[huge_free_region]);
 
     size_t free_space_in_huge_regions = global_free_huge_regions.get_size_free_regions();
+    size_t free_space_in_young_huge_regions = global_free_huge_regions.get_size_free_regions(MIN_AGE_TO_DECOMMIT_HUGE - 1);
 
     ptrdiff_t num_regions_to_decommit[kind_count];
     int region_factor[kind_count] = { 1, LARGE_REGION_FACTOR };
@@ -13384,6 +13400,7 @@ void gc_heap::distribute_free_regions()
 #endif //!MULTIPLE_HEAPS
 
     size_t num_huge_region_units_to_consider[kind_count] = { 0, free_space_in_huge_regions / region_size[large_free_region] };
+    size_t num_young_huge_region_units_to_consider[kind_count] = { 0, free_space_in_young_huge_regions / region_size[large_free_region] };
 
     for (int kind = basic_free_region; kind < kind_count; kind++)
     {
@@ -13402,9 +13419,22 @@ void gc_heap::distribute_free_regions()
 
         ptrdiff_t balance = total_num_free_regions[kind] + num_huge_region_units_to_consider[kind] - total_budget_in_region_units[kind];
 
+        // Ignore young huge regions if they are contributing to a surplus.
+        if (balance > 0)
+        {
+            if (balance > static_cast<ptrdiff_t>(num_young_huge_region_units_to_consider[kind]))
+            {
+                balance -= num_young_huge_region_units_to_consider[kind];
+            }
+            else
+            {
+                balance = 0;
+            }
+        }
+
         if (
 #ifdef BACKGROUND_GC
-            background_running_p() ||
+            (background_running_p() && (settings.condemned_generation != max_generation)) ||
 #endif
             (balance < 0))
         {
@@ -13588,6 +13618,43 @@ void gc_heap::distribute_free_regions()
 #endif //USE_REGIONS
 }
 
+void gc_heap::age_free_regions(const char* label)
+{
+#ifdef USE_REGIONS
+    // If we are doing an ephemeral GC as a precursor to a BGC, then we will age all of the region
+    // kinds during the ephemeral GC and skip the call to age_free_regions during the BGC itself.
+    bool age_all_region_kinds = (settings.condemned_generation == max_generation) || is_bgc_in_progress();
+    if (age_all_region_kinds)
+    {
+        global_free_huge_regions.age_free_regions();
+    }
+
+#ifdef MULTIPLE_HEAPS
+    for (int i = 0; i < gc_heap::n_heaps; i++)
+    {
+        gc_heap* hp = gc_heap::g_heaps[i];
+#else //MULTIPLE_HEAPS
+    {
+        gc_heap* hp = pGenGCHeap;
+        const int i = 0;
+#endif //MULTIPLE_HEAPS
+
+        if (age_all_region_kinds)
+        {
+            // age and print all kinds of free regions
+            region_free_list::age_free_regions (hp->free_regions);
+            region_free_list::print (hp->free_regions, i, label);
+        }
+        else
+        {
+            // age and print only basic free regions
+            hp->free_regions[basic_free_region].age_free_regions();
+            hp->free_regions[basic_free_region].print (i, label);
+        }
+    }
+#endif //USE_REGIONS
+}
+
 #ifdef WRITE_WATCH
 uint8_t* g_addresses [array_size+2]; // to get around the bug in GetWriteWatch
 
@@ -22765,21 +22832,8 @@ void gc_heap::gc1()
             for (int i = 0; i < gc_heap::n_heaps; i++)
             {
                 g_heaps[i]->descr_generations ("END");
-#ifdef USE_REGIONS
-                if (settings.condemned_generation == max_generation)
-                {
-                    // age and print all kinds of free regions
-                    region_free_list::age_free_regions (g_heaps[i]->free_regions);
-                    region_free_list::print (g_heaps[i]->free_regions, i, "END");
-                }
-                else
-                {
-                    // age and print only basic free regions
-                    g_heaps[i]->free_regions[basic_free_region].age_free_regions();
-                    g_heaps[i]->free_regions[basic_free_region].print (i, "END");
-                }
-#endif //USE_REGIONS
             }
+            age_free_regions ("END");
 
 #ifdef DYNAMIC_HEAP_COUNT
             update_total_soh_stable_size();
@@ -22819,18 +22873,7 @@ void gc_heap::gc1()
         compute_gc_and_ephemeral_range (settings.condemned_generation, true);
         stomp_write_barrier_ephemeral (ephemeral_low, ephemeral_high,
                                         map_region_to_generation_skewed, (uint8_t)min_segment_size_shr);
-        if (settings.condemned_generation == max_generation)
-        {
-            // age and print all kinds of free regions
-            region_free_list::age_free_regions(free_regions);
-            region_free_list::print(free_regions, 0, "END");
-        }
-        else
-        {
-            // age and print only basic free regions
-            free_regions[basic_free_region].age_free_regions();
-            free_regions[basic_free_region].print (0, "END");
-        }
+        age_free_regions ("END");
 #endif //USE_REGIONS
 
         update_end_ngc_time();
@@ -37501,7 +37544,15 @@ void gc_heap::allow_fgc()
 
 BOOL gc_heap::is_bgc_in_progress()
 {
-    return (background_running_p() || (current_bgc_state == bgc_initialized));
+#ifdef MULTIPLE_HEAPS
+    // All heaps are changed to/from the bgc_initialized state during the VM suspension at the start of BGC,
+    // so checking any heap will work.
+    gc_heap* hp = gc_heap::g_heaps[0];
+#else
+    gc_heap* hp = pGenGCHeap;
+#endif //MULTIPLE_HEAPS
+
+    return (background_running_p() || (hp->current_bgc_state == bgc_initialized));
 }
 
 void gc_heap::clear_commit_flag()
@@ -38016,6 +38067,14 @@ void gc_heap::background_mark_phase ()
     if (bgc_t_join.joined())
 #endif //MULTIPLE_HEAPS
     {
+        // There's no need to distribute a second time if we just did an ephemeral GC, and we don't want to
+        // age the free regions twice.
+        if (!do_ephemeral_gc_p)
+        {
+            distribute_free_regions ();
+            age_free_regions ("BGC");
+        }
+
 #ifdef FEATURE_USE_SOFTWARE_WRITE_WATCH_FOR_GC_HEAP
         // Resetting write watch for software write watch is pretty fast, much faster than for hardware write watch. Reset
         // can be done while the runtime is suspended or after the runtime is restarted, the preference was to reset while

src/coreclr/gc/gcpriv.h

@@ -1402,6 +1402,7 @@ class region_free_list
     size_t get_num_free_regions();
     size_t get_size_committed_in_free() { return size_committed_in_free_regions; }
     size_t get_size_free_regions() { return size_free_regions; }
+    size_t get_size_free_regions(int max_age);
     heap_segment* get_first_free_region() { return head_free_region; }
     static void unlink_region (heap_segment* region);
     static void add_region (heap_segment* region, region_free_list to_free_list[count_free_region_kinds]);
@@ -2410,6 +2411,7 @@ class gc_heap
 #endif //!USE_REGIONS
     PER_HEAP_METHOD void delay_free_segments();
     PER_HEAP_ISOLATED_METHOD void distribute_free_regions();
+    PER_HEAP_ISOLATED_METHOD void age_free_regions(const char* label);
 #ifdef BACKGROUND_GC
     PER_HEAP_ISOLATED_METHOD void reset_write_watch_for_gc_heap(void* base_address, size_t region_size);
     PER_HEAP_ISOLATED_METHOD void get_write_watch_for_gc_heap(bool reset, void *base_address, size_t region_size, void** dirty_pages, uintptr_t* dirty_page_count_ref, bool is_runtime_suspended);
@@ -3186,7 +3188,7 @@ class gc_heap
     // Restores BGC settings if necessary.
     PER_HEAP_ISOLATED_METHOD void recover_bgc_settings();
 
-    PER_HEAP_METHOD BOOL is_bgc_in_progress();
+    PER_HEAP_ISOLATED_METHOD BOOL is_bgc_in_progress();
 
     PER_HEAP_METHOD void clear_commit_flag();
 
@@ -6045,6 +6047,7 @@ class heap_segment
     // the region's free list.
     #define MAX_AGE_IN_FREE 99
     #define AGE_IN_FREE_TO_DECOMMIT 20
+    #define MIN_AGE_TO_DECOMMIT_HUGE 2
     int             age_in_free;
     // This is currently only used by regions that are swept in plan -
     // we then thread this list onto the generation's free list.