changes to help diag init failure related to regions and expose more region size related configs in runtimeconfig (#114944)

Maoni0 · web-flow · commit 9a879d3980bd · 2025-05-02T11:21:05.000-07:00
lately I've seen a couple of customer reports where the GC initialization failed to reserve the default 256GB of virtual memory for the regions range, to make this easier to diagnose I've added this as an error communicated to host. so you would see something like this 

C:\temp&gt;dotnet GCPerfSim.dll -tc 28 -tagb 50 -tlgb 2 -lohar 0 -sohsi 50 -lohsi 0 -pohsi 0 -sohpi 100 -lohpi 0 -sohfi 0 -lohfi 0 -pohfi 0 -allocType reference -testKind time
GC: Reserving 274877906944 bytes (256 GiB) for the regions range failed, do you have a virtual memory limit set on this process?
GC heap initialization failed with error 0x8007000E
Failed to create CoreCLR, HRESULT: 0x8007000E

also added a few other places where we might hit and got rid of some that are only for private testing. I'm not adding this for every single case where it could fail as they are really unlikely to be hit. 

since the solution is to adjust some region configs I also exposed them to the runtimeconfig. 

and fixed a typo I had for a config for private testing.
diff --git a/src/coreclr/gc/gc.cpp b/src/coreclr/gc/gc.cpp
@@ -427,6 +427,12 @@ float mb (size_t num)
     return (float)((float)num / 1000.0 / 1000.0);
 }
 
+inline
+size_t gib (size_t num)
+{
+    return (num / 1024 / 1024 / 1024);
+}
+
 #ifdef BACKGROUND_GC
 uint32_t bgc_alloc_spin_count = 140;
 uint32_t bgc_alloc_spin_count_uoh = 16;
@@ -3908,6 +3914,10 @@ bool region_allocator::init (uint8_t* start, uint8_t* end, size_t alignment, uin
         *lowest = global_region_start;
         *highest = global_region_end;
     }
+    else
+    {
+        log_init_error_to_host ("global region allocator failed to allocate %zd bytes during init", (total_num_units * sizeof (uint32_t)));
+    }
 
     return (unit_map != 0);
 }
@@ -9467,6 +9477,7 @@ bool gc_heap::inplace_commit_card_table (uint8_t* from, uint8_t* to)
             succeed = virtual_commit (commit_begins[i], commit_sizes[i], recorded_committed_bookkeeping_bucket);
             if (!succeed)
             {
+                log_init_error_to_host ("Committing %zd bytes (%.3f mb) for GC bookkeeping element#%d failed", commit_sizes[i], mb (commit_sizes[i]), i);
                 failed_commit = i;
                 break;
             }
@@ -9520,7 +9531,10 @@ uint32_t* gc_heap::make_card_table (uint8_t* start, uint8_t* end)
     bookkeeping_start = mem;
 
     if (!mem)
+    {
+        log_init_error_to_host ("Reserving %zd bytes (%.3f mb) for GC bookkeeping failed", alloc_size, mb (alloc_size));
         return 0;
+    }
 
     dprintf (2, ("Init - Card table alloc for %zd bytes: [%zx, %zx[",
                  alloc_size, (size_t)mem, (size_t)(mem+alloc_size)));
@@ -12398,6 +12412,7 @@ heap_segment* gc_heap::make_heap_segment (uint8_t* new_pages, size_t size, gc_he
 
     if (!virtual_commit (new_pages, initial_commit, oh, h_number))
     {
+        log_init_error_to_host ("Committing %zd bytes for a region failed", initial_commit);
         return 0;
     }
 
@@ -14345,6 +14360,7 @@ bool allocate_initial_regions(int number_of_heaps)
     initial_regions = new (nothrow) uint8_t*[number_of_heaps][total_generation_count][2];
     if (initial_regions == nullptr)
     {
+        log_init_error_to_host ("allocate_initial_regions failed to allocate %zd bytes", (number_of_heaps * total_generation_count * 2 * sizeof (uint8_t*)));
         return false;
     }
     for (int i = 0; i < number_of_heaps; i++)
@@ -14407,7 +14423,6 @@ HRESULT gc_heap::initialize_gc (size_t soh_segment_size,
 
         if (gc_config_log == NULL)
         {
-            GCToEEInterface::LogErrorToHost("Cannot create log file");
             return E_FAIL;
         }
 
@@ -14532,7 +14547,11 @@ HRESULT gc_heap::initialize_gc (size_t soh_segment_size,
         size_t reserve_size = regions_range;
         uint8_t* reserve_range = (uint8_t*)virtual_alloc (reserve_size, use_large_pages_p);
         if (!reserve_range)
+        {
+            log_init_error_to_host ("Reserving %zd bytes (%zd GiB) for the regions range failed, do you have a virtual memory limit set on this process?",
+                reserve_size, gib (reserve_size));
             return E_OUTOFMEMORY;
+        }
 
         if (!global_region_allocator.init (reserve_range, (reserve_range + reserve_size),
                                            ((size_t)1 << min_segment_size_shr),
@@ -14545,7 +14564,7 @@ HRESULT gc_heap::initialize_gc (size_t soh_segment_size,
     else
     {
         assert (!"cannot use regions without specifying the range!!!");
-        GCToEEInterface::LogErrorToHost("Cannot use regions without specifying the range (using DOTNET_GCRegionRange)");
+        log_init_error_to_host ("Regions range is 0! unexpected");
         return E_FAIL;
     }
 #else //USE_REGIONS
@@ -14685,7 +14704,7 @@ HRESULT gc_heap::initialize_gc (size_t soh_segment_size,
 
     if (!init_semi_shared())
     {
-        GCToEEInterface::LogErrorToHost("PER_HEAP_ISOLATED data members initialization failed");
+        log_init_error_to_host ("PER_HEAP_ISOLATED data members initialization failed");
         hres = E_FAIL;
     }
 
@@ -49226,6 +49245,7 @@ HRESULT GCHeap::Initialize()
     memset (gc_heap::committed_by_oh, 0, sizeof (gc_heap::committed_by_oh));
     if (!gc_heap::compute_hard_limit())
     {
+        log_init_error_to_host ("compute_hard_limit failed, check your heap hard limit related configs");
         return CLR_E_GC_BAD_HARD_LIMIT;
     }
 
@@ -49243,6 +49263,7 @@ HRESULT GCHeap::Initialize()
     uintptr_t config_affinity_mask = static_cast<uintptr_t>(GCConfig::GetGCHeapAffinitizeMask());
     if (!ParseGCHeapAffinitizeRanges(cpu_index_ranges_holder.Get(), &config_affinity_set, config_affinity_mask))
     {
+        log_init_error_to_host ("ParseGCHeapAffinitizeRange failed, check your HeapAffinitizeRanges config");
         return CLR_E_GC_BAD_AFFINITY_CONFIG_FORMAT;
     }
 
@@ -49251,6 +49272,7 @@ HRESULT GCHeap::Initialize()
 
     if (process_affinity_set->IsEmpty())
     {
+        log_init_error_to_host ("This process is affinitize to 0 CPUs, check your GC heap affinity related configs");
         return CLR_E_GC_BAD_AFFINITY_CONFIG;
     }
 
@@ -49393,6 +49415,8 @@ HRESULT GCHeap::Initialize()
 
     if (gc_region_size >= MAX_REGION_SIZE)
     {
+        log_init_error_to_host ("The GC RegionSize config is set to %zd bytes (%zd GiB), it needs to be < %zd GiB",
+            gc_region_size, gib (gc_region_size), gib (MAX_REGION_SIZE));
         return CLR_E_GC_BAD_REGION_SIZE;
     }
 
@@ -49421,6 +49445,8 @@ HRESULT GCHeap::Initialize()
 
     if (!power_of_two_p(gc_region_size) || ((gc_region_size * nhp * min_regions_per_heap) > gc_heap::regions_range))
     {
+        log_init_error_to_host ("Region size is %zd bytes, range is %zd bytes, (%d heaps * %d regions/heap = %d) regions needed initially",
+            gc_region_size, gc_heap::regions_range, nhp, min_regions_per_heap, (nhp * min_regions_per_heap));
         return E_OUTOFMEMORY;
     }
 
@@ -49495,7 +49521,7 @@ HRESULT GCHeap::Initialize()
 
     if (!WaitForGCEvent->CreateManualEventNoThrow(TRUE))
     {
-        GCToEEInterface::LogErrorToHost("Creation of WaitForGCEvent failed");
+        log_init_error_to_host ("Creation of WaitForGCEvent failed");
         return E_FAIL;
     }
 
@@ -49584,12 +49610,10 @@ HRESULT GCHeap::Initialize()
         uint8_t* numa_mem = (uint8_t*)GCToOSInterface::VirtualReserve (hb_info_size_per_node, 0, 0, (uint16_t)numa_node_index);
         if (!numa_mem)
         {
-            GCToEEInterface::LogErrorToHost("Reservation of numa_mem failed");
             return E_FAIL;
         }
         if (!GCToOSInterface::VirtualCommit (numa_mem, hb_info_size_per_node, (uint16_t)numa_node_index))
         {
-            GCToEEInterface::LogErrorToHost("Commit of numa_mem failed");
             return E_FAIL;
         }
 
@@ -49691,7 +49715,6 @@ HRESULT GCHeap::Initialize()
 
             if (seg_mem == nullptr)
             {
-                GCToEEInterface::LogErrorToHost("STRESS_REGIONS couldn't allocate ro segment");
                 hr = E_FAIL;
                 break;
             }
@@ -49705,7 +49728,6 @@ HRESULT GCHeap::Initialize()
 
             if (!RegisterFrozenSegment(&seg_info))
             {
-                GCToEEInterface::LogErrorToHost("STRESS_REGIONS failed to RegisterFrozenSegment");
                 hr = E_FAIL;
                 break;
             }
diff --git a/src/coreclr/gc/gc.h b/src/coreclr/gc/gc.h
@@ -392,4 +392,6 @@ void GCLog (const char *fmt, ... );
 FILE* CreateLogFile(const GCConfigStringHolder& temp_logfile_name, bool is_config);
 #endif //TRACE_GC || GC_CONFIG_DRIVEN
 
+void log_init_error_to_host (const char* format, ...);
+
 #endif // __GC_H
diff --git a/src/coreclr/gc/gccommon.cpp b/src/coreclr/gc/gccommon.cpp
@@ -132,6 +132,12 @@ FILE* CreateLogFile(const GCConfigStringHolder& temp_logfile_name, bool is_confi
     //_snprintf_s(logfile_name, MAX_LONGPATH+1, _TRUNCATE, "%s.%d%s", temp_logfile_name.Get(), pid, suffix);
     _snprintf_s(logfile_name, MAX_LONGPATH+1, _TRUNCATE, "%s%s", temp_logfile_name.Get(), suffix);
     logFile = fopen(logfile_name, "wb");
+
+    if (logFile == NULL)
+    {
+        log_init_error_to_host ("Cannot create log file %s", logfile_name);
+    }
+
     return logFile;
 }
 #endif //TRACE_GC || GC_CONFIG_DRIVEN
@@ -159,7 +165,6 @@ HRESULT initialize_log_file()
 
         if (gc_log == NULL)
         {
-            GCToEEInterface::LogErrorToHost("Cannot create log file");
             return E_FAIL;
         }
 
@@ -168,7 +173,7 @@ HRESULT initialize_log_file()
 
         if (gc_log_file_size <= 0 || gc_log_file_size > 500)
         {
-            GCToEEInterface::LogErrorToHost("Invalid log file size (valid size needs to be larger than 0 and smaller than 500)");
+            log_init_error_to_host ("Invalid log file size %zd MiB (valid size needs to be > 0 and <= 500 MiB)", gc_log_file_size);
             fclose (gc_log);
             return E_FAIL;
         }
@@ -265,4 +270,15 @@ void GCLog (const char *fmt, ... )
 }
 #endif //TRACE_GC && SIMPLE_DPRINTF
 
+// We log initialization errors to the host to help with diagnostics. By default these will show up in stdout.
+// You can also redirect them to a file. See docs/design/features/host-tracing.md.
+void log_init_error_to_host (const char* format, ...)
+{
+    char error_buf[256];
+    va_list args;
+    va_start (args, format);
+    _vsnprintf_s (error_buf, ARRAY_SIZE (error_buf), _TRUNCATE, format, args);
+    GCToEEInterface::LogErrorToHost (error_buf);
+    va_end (args);
+}
 #endif // !DACCESS_COMPILE
diff --git a/src/coreclr/gc/gcconfig.h b/src/coreclr/gc/gcconfig.h
@@ -104,8 +104,8 @@ class GCConfigStringHolder
     INT_CONFIG   (GCHeapHardLimit,           "GCHeapHardLimit",           "System.GC.HeapHardLimit",           0,                  "Specifies a hard limit for the GC heap")                                                 \
     INT_CONFIG   (GCHeapHardLimitPercent,    "GCHeapHardLimitPercent",    "System.GC.HeapHardLimitPercent",    0,                  "Specifies the GC heap usage as a percentage of the total memory")                        \
     INT_CONFIG   (GCTotalPhysicalMemory,     "GCTotalPhysicalMemory",     NULL,                                0,                  "Specifies what the GC should consider to be total physical memory")                      \
-    INT_CONFIG   (GCRegionRange,             "GCRegionRange",             NULL,                                0,                  "Specifies the range for the GC heap")                                                    \
-    INT_CONFIG   (GCRegionSize,              "GCRegionSize",              NULL,                                0,                  "Specifies the size for a basic GC region")                                               \
+    INT_CONFIG   (GCRegionRange,             "GCRegionRange",             "System.GC.RegionRange",             0,                  "Specifies the range for the GC heap")                                                    \
+    INT_CONFIG   (GCRegionSize,              "GCRegionSize",              "System.GC.RegionSize",              0,                  "Specifies the size for a basic GC region")                                               \
     INT_CONFIG   (GCEnableSpecialRegions,    "GCEnableSpecialRegions",    NULL,                                0,                  "Specifies to enable special handling some regions like SIP")                             \
     STRING_CONFIG(LogFile,                   "GCLogFile",                 NULL,                                                    "Specifies the name of the GC log file")                                                  \
     STRING_CONFIG(ConfigLogFile,             "GCConfigLogFile",           NULL,                                                    "Specifies the name of the GC config log file")                                           \
@@ -142,7 +142,7 @@ class GCConfigStringHolder
     INT_CONFIG   (GCSpinCountUnit,           "GCSpinCountUnit",           NULL,                                0,                  "Specifies the spin count unit used by the GC.")                                          \
     INT_CONFIG   (GCDynamicAdaptationMode,   "GCDynamicAdaptationMode",   "System.GC.DynamicAdaptationMode",   1,                  "Enable the GC to dynamically adapt to application sizes.")                               \
     INT_CONFIG   (GCDTargetTCP,              "GCDTargetTCP",              "System.GC.DTargetTCP",              0,                  "Specifies the target tcp for DATAS")                                                     \
-    INT_CONFIG   (GCDBGCRatio,              " GCDBGCRatio",               NULL,                                0,                  "Specifies the ratio of BGC to NGC2 for HC change")                                       \
+    INT_CONFIG   (GCDBGCRatio,               "GCDBGCRatio",               NULL,                                0,                  "Specifies the ratio of BGC to NGC2 for HC change")                                       \
     BOOL_CONFIG  (GCCacheSizeFromSysConf,    "GCCacheSizeFromSysConf",    NULL,                                false,              "Specifies using sysconf to retrieve the last level cache size for Unix.")
 
 // This class is responsible for retreiving configuration information

Original file line number	Diff line number	Diff line change
`@@ -427,6 +427,12 @@ float mb (size_t num)`
`427`	`427`	`return (float)((float)num / 1000.0 / 1000.0);`
`428`	`428`	`}`
`429`	`429`
	`430`	`+inline`
	`431`	`+size_t gib (size_t num)`
	`432`	`+{`
	`433`	`+ return (num / 1024 / 1024 / 1024);`
	`434`	`+}`
	`435`	`+`
`430`	`436`	`#ifdef BACKGROUND_GC`
`431`	`437`	`uint32_t bgc_alloc_spin_count = 140;`
`432`	`438`	`uint32_t bgc_alloc_spin_count_uoh = 16;`
`@@ -3908,6 +3914,10 @@ bool region_allocator::init (uint8_t* start, uint8_t* end, size_t alignment, uin`
`3908`	`3914`	`*lowest = global_region_start;`
`3909`	`3915`	`*highest = global_region_end;`
`3910`	`3916`	`}`
	`3917`	`+ else`
	`3918`	`+ {`
	`3919`	`+ log_init_error_to_host ("global region allocator failed to allocate %zd bytes during init", (total_num_units * sizeof (uint32_t)));`
	`3920`	`+ }`
`3911`	`3921`
`3912`	`3922`	`return (unit_map != 0);`
`3913`	`3923`	`}`
`@@ -9467,6 +9477,7 @@ bool gc_heap::inplace_commit_card_table (uint8_t* from, uint8_t* to)`
`9467`	`9477`	`succeed = virtual_commit (commit_begins[i], commit_sizes[i], recorded_committed_bookkeeping_bucket);`
`9468`	`9478`	`if (!succeed)`
`9469`	`9479`	`{`
	`9480`	`+ log_init_error_to_host ("Committing %zd bytes (%.3f mb) for GC bookkeeping element#%d failed", commit_sizes[i], mb (commit_sizes[i]), i);`
`9470`	`9481`	`failed_commit = i;`
`9471`	`9482`	`break;`
`9472`	`9483`	`}`
`@@ -9520,7 +9531,10 @@ uint32_t* gc_heap::make_card_table (uint8_t* start, uint8_t* end)`
`9520`	`9531`	`bookkeeping_start = mem;`
`9521`	`9532`
`9522`	`9533`	`if (!mem)`
	`9534`	`+ {`
	`9535`	`+ log_init_error_to_host ("Reserving %zd bytes (%.3f mb) for GC bookkeeping failed", alloc_size, mb (alloc_size));`
`9523`	`9536`	`return 0;`
	`9537`	`+ }`
`9524`	`9538`
`9525`	`9539`	`dprintf (2, ("Init - Card table alloc for %zd bytes: [%zx, %zx[",`
`9526`	`9540`	`alloc_size, (size_t)mem, (size_t)(mem+alloc_size)));`
`@@ -12398,6 +12412,7 @@ heap_segment* gc_heap::make_heap_segment (uint8_t* new_pages, size_t size, gc_he`
`12398`	`12412`
`12399`	`12413`	`if (!virtual_commit (new_pages, initial_commit, oh, h_number))`
`12400`	`12414`	`{`
	`12415`	`+ log_init_error_to_host ("Committing %zd bytes for a region failed", initial_commit);`
`12401`	`12416`	`return 0;`
`12402`	`12417`	`}`
`12403`	`12418`
`@@ -14345,6 +14360,7 @@ bool allocate_initial_regions(int number_of_heaps)`
`14345`	`14360`	`initial_regions = new (nothrow) uint8_t*[number_of_heaps][total_generation_count][2];`
`14346`	`14361`	`if (initial_regions == nullptr)`
`14347`	`14362`	`{`
	`14363`	`+ log_init_error_to_host ("allocate_initial_regions failed to allocate %zd bytes", (number_of_heaps * total_generation_count * 2 * sizeof (uint8_t*)));`
`14348`	`14364`	`return false;`
`14349`	`14365`	`}`
`14350`	`14366`	`for (int i = 0; i < number_of_heaps; i++)`
`@@ -14407,7 +14423,6 @@ HRESULT gc_heap::initialize_gc (size_t soh_segment_size,`
`14407`	`14423`
`14408`	`14424`	`if (gc_config_log == NULL)`
`14409`	`14425`	`{`
`14410`		`- GCToEEInterface::LogErrorToHost("Cannot create log file");`
`14411`	`14426`	`return E_FAIL;`
`14412`	`14427`	`}`
`14413`	`14428`
`@@ -14532,7 +14547,11 @@ HRESULT gc_heap::initialize_gc (size_t soh_segment_size,`
`14532`	`14547`	`size_t reserve_size = regions_range;`
`14533`	`14548`	`uint8_t* reserve_range = (uint8_t*)virtual_alloc (reserve_size, use_large_pages_p);`
`14534`	`14549`	`if (!reserve_range)`
	`14550`	`+ {`
	`14551`	`+ log_init_error_to_host ("Reserving %zd bytes (%zd GiB) for the regions range failed, do you have a virtual memory limit set on this process?",`
	`14552`	`+ reserve_size, gib (reserve_size));`
`14535`	`14553`	`return E_OUTOFMEMORY;`
	`14554`	`+ }`
`14536`	`14555`
`14537`	`14556`	`if (!global_region_allocator.init (reserve_range, (reserve_range + reserve_size),`
`14538`	`14557`	`((size_t)1 << min_segment_size_shr),`
`@@ -14545,7 +14564,7 @@ HRESULT gc_heap::initialize_gc (size_t soh_segment_size,`
`14545`	`14564`	`else`
`14546`	`14565`	`{`
`14547`	`14566`	`assert (!"cannot use regions without specifying the range!!!");`
`14548`		`- GCToEEInterface::LogErrorToHost("Cannot use regions without specifying the range (using DOTNET_GCRegionRange)");`
	`14567`	`+ log_init_error_to_host ("Regions range is 0! unexpected");`
`14549`	`14568`	`return E_FAIL;`
`14550`	`14569`	`}`
`14551`	`14570`	`#else //USE_REGIONS`
`@@ -14685,7 +14704,7 @@ HRESULT gc_heap::initialize_gc (size_t soh_segment_size,`
`14685`	`14704`
`14686`	`14705`	`if (!init_semi_shared())`
`14687`	`14706`	`{`
`14688`		`- GCToEEInterface::LogErrorToHost("PER_HEAP_ISOLATED data members initialization failed");`
	`14707`	`+ log_init_error_to_host ("PER_HEAP_ISOLATED data members initialization failed");`
`14689`	`14708`	`hres = E_FAIL;`
`14690`	`14709`	`}`
`14691`	`14710`
`@@ -49226,6 +49245,7 @@ HRESULT GCHeap::Initialize()`
`49226`	`49245`	`memset (gc_heap::committed_by_oh, 0, sizeof (gc_heap::committed_by_oh));`
`49227`	`49246`	`if (!gc_heap::compute_hard_limit())`
`49228`	`49247`	`{`
	`49248`	`+ log_init_error_to_host ("compute_hard_limit failed, check your heap hard limit related configs");`
`49229`	`49249`	`return CLR_E_GC_BAD_HARD_LIMIT;`
`49230`	`49250`	`}`
`49231`	`49251`
`@@ -49243,6 +49263,7 @@ HRESULT GCHeap::Initialize()`
`49243`	`49263`	`uintptr_t config_affinity_mask = static_cast<uintptr_t>(GCConfig::GetGCHeapAffinitizeMask());`
`49244`	`49264`	`if (!ParseGCHeapAffinitizeRanges(cpu_index_ranges_holder.Get(), &config_affinity_set, config_affinity_mask))`
`49245`	`49265`	`{`
	`49266`	`+ log_init_error_to_host ("ParseGCHeapAffinitizeRange failed, check your HeapAffinitizeRanges config");`
`49246`	`49267`	`return CLR_E_GC_BAD_AFFINITY_CONFIG_FORMAT;`
`49247`	`49268`	`}`
`49248`	`49269`
`@@ -49251,6 +49272,7 @@ HRESULT GCHeap::Initialize()`
`49251`	`49272`
`49252`	`49273`	`if (process_affinity_set->IsEmpty())`
`49253`	`49274`	`{`
	`49275`	`+ log_init_error_to_host ("This process is affinitize to 0 CPUs, check your GC heap affinity related configs");`
`49254`	`49276`	`return CLR_E_GC_BAD_AFFINITY_CONFIG;`
`49255`	`49277`	`}`
`49256`	`49278`
`@@ -49393,6 +49415,8 @@ HRESULT GCHeap::Initialize()`
`49393`	`49415`
`49394`	`49416`	`if (gc_region_size >= MAX_REGION_SIZE)`
`49395`	`49417`	`{`
	`49418`	`+ log_init_error_to_host ("The GC RegionSize config is set to %zd bytes (%zd GiB), it needs to be < %zd GiB",`
	`49419`	`+ gc_region_size, gib (gc_region_size), gib (MAX_REGION_SIZE));`
`49396`	`49420`	`return CLR_E_GC_BAD_REGION_SIZE;`
`49397`	`49421`	`}`
`49398`	`49422`
`@@ -49421,6 +49445,8 @@ HRESULT GCHeap::Initialize()`
`49421`	`49445`
`49422`	`49446`	`if (!power_of_two_p(gc_region_size) \|\| ((gc_region_size * nhp * min_regions_per_heap) > gc_heap::regions_range))`
`49423`	`49447`	`{`
	`49448`	`+ log_init_error_to_host ("Region size is %zd bytes, range is %zd bytes, (%d heaps * %d regions/heap = %d) regions needed initially",`
	`49449`	`+ gc_region_size, gc_heap::regions_range, nhp, min_regions_per_heap, (nhp * min_regions_per_heap));`
`49424`	`49450`	`return E_OUTOFMEMORY;`
`49425`	`49451`	`}`
`49426`	`49452`
`@@ -49495,7 +49521,7 @@ HRESULT GCHeap::Initialize()`
`49495`	`49521`
`49496`	`49522`	`if (!WaitForGCEvent->CreateManualEventNoThrow(TRUE))`
`49497`	`49523`	`{`
`49498`		`- GCToEEInterface::LogErrorToHost("Creation of WaitForGCEvent failed");`
	`49524`	`+ log_init_error_to_host ("Creation of WaitForGCEvent failed");`
`49499`	`49525`	`return E_FAIL;`
`49500`	`49526`	`}`
`49501`	`49527`
`@@ -49584,12 +49610,10 @@ HRESULT GCHeap::Initialize()`
`49584`	`49610`	`uint8_t* numa_mem = (uint8_t*)GCToOSInterface::VirtualReserve (hb_info_size_per_node, 0, 0, (uint16_t)numa_node_index);`
`49585`	`49611`	`if (!numa_mem)`
`49586`	`49612`	`{`
`49587`		`- GCToEEInterface::LogErrorToHost("Reservation of numa_mem failed");`
`49588`	`49613`	`return E_FAIL;`
`49589`	`49614`	`}`
`49590`	`49615`	`if (!GCToOSInterface::VirtualCommit (numa_mem, hb_info_size_per_node, (uint16_t)numa_node_index))`
`49591`	`49616`	`{`
`49592`		`- GCToEEInterface::LogErrorToHost("Commit of numa_mem failed");`
`49593`	`49617`	`return E_FAIL;`
`49594`	`49618`	`}`
`49595`	`49619`
`@@ -49691,7 +49715,6 @@ HRESULT GCHeap::Initialize()`
`49691`	`49715`
`49692`	`49716`	`if (seg_mem == nullptr)`
`49693`	`49717`	`{`
`49694`		`- GCToEEInterface::LogErrorToHost("STRESS_REGIONS couldn't allocate ro segment");`
`49695`	`49718`	`hr = E_FAIL;`
`49696`	`49719`	`break;`
`49697`	`49720`	`}`
`@@ -49705,7 +49728,6 @@ HRESULT GCHeap::Initialize()`
`49705`	`49728`
`49706`	`49729`	`if (!RegisterFrozenSegment(&seg_info))`
`49707`	`49730`	`{`
`49708`		`- GCToEEInterface::LogErrorToHost("STRESS_REGIONS failed to RegisterFrozenSegment");`
`49709`	`49731`	`hr = E_FAIL;`
`49710`	`49732`	`break;`
`49711`	`49733`	`}`