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

Maoni0 · Maoni0 · commit 962a3b1131a6 · 2025-04-22T20:15:57.000-07:00
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`	`}`