Address code review feedback - unify code branches that branch to the failure case. Also keep data types as uint64_t as long as possible to avoid size_t overflow

Author: swgillespie

src/gc/gc.cpp

@@ -15883,54 +15883,60 @@ start_no_gc_region_status gc_heap::prepare_for_no_gc_region (uint64_t total_size
     settings.pause_mode = pause_no_gc;
     current_no_gc_region_info.start_status = start_no_gc_success;
 
-    size_t allocation_no_gc_loh = 0;
-    size_t allocation_no_gc_soh = 0;
-    size_t size_per_heap = 0;
+    uint64_t allocation_no_gc_loh = 0;
+    uint64_t allocation_no_gc_soh = 0;
+    assert(total_size != 0);
+    if (loh_size_known)
+    {
+        assert(loh_size != 0);
+        assert(loh_size <= total_size);
+        allocation_no_gc_loh = loh_size;
+        allocation_no_gc_soh = total_size - loh_size;
+    }
+    else
+    {
+        allocation_no_gc_soh = total_size;
+        allocation_no_gc_loh = total_size;
+    }
+
     int soh_align_const = get_alignment_constant (TRUE);
-    size_t max_soh_allocated = (soh_segment_size - segment_info_size - eph_gen_starts_size);
+    size_t max_soh_allocated = soh_segment_size - segment_info_size - eph_gen_starts_size;
+    const double scale_factor = 1.05;
+
     int num_heaps = 1;
 #ifdef MULTIPLE_HEAPS
     num_heaps = n_heaps;
-#endif //MULTIPLE_HEAPS
-    size_t total_allowed_soh_allocation = max_soh_allocated * num_heaps;
-    const size_t max_alloc_scale = static_cast<size_t>(SIZE_T_MAX / 1.05f);
+#endif // MULTIPLE_HEAPS
 
-    assert(total_size != 0);
-    // requested sizes that would cause 1.05 * total_size to not fit in a size_t
-    // make no sense.
-    if (total_size > max_alloc_scale)
+    uint64_t total_allowed_soh_allocation = max_soh_allocated * num_heaps;
+    // In theory, the upper limit here is the physical memory of the machine, not
+    // SIZE_T_MAX. This is not true today because total_physical_mem can be
+    // larger than SIZE_T_MAX if running in wow64 on a machine with more than
+    // 4GB of RAM. Once Local GC code divergence is resolved and code is flowing
+    // more freely between branches, it would be good to clean this up to use
+    // total_physical_mem instead of SIZE_T_MAX.
+    assert(total_allowed_soh_allocation <= SIZE_T_MAX);
+    uint64_t total_allowed_loh_allocation = SIZE_T_MAX;
+    uint64_t total_allowed_soh_alloc_scaled = allocation_no_gc_soh > 0 ? static_cast<uint64_t>(total_allowed_soh_allocation / scale_factor) : 0;
+    uint64_t total_allowed_loh_alloc_scaled = allocation_no_gc_loh > 0 ? static_cast<uint64_t>(total_allowed_loh_allocation / scale_factor) : 0;
+
+    if (allocation_no_gc_soh > total_allowed_soh_alloc_scaled ||
+        allocation_no_gc_loh > total_allowed_loh_alloc_scaled)
     {
         status = start_no_gc_too_large;
         goto done;
     }
 
-    if (loh_size_known)
+    if (allocation_no_gc_soh > 0)
     {
-        assert(loh_size != 0);
-        assert(loh_size <= total_size);
-
-        // same for loh_size.
-        if (loh_size > max_alloc_scale)
-        {
-            status = start_no_gc_too_large;
-            goto done;
-        }
+        allocation_no_gc_soh = static_cast<uint64_t>(allocation_no_gc_soh * scale_factor);
+        allocation_no_gc_soh = min (allocation_no_gc_soh, total_allowed_soh_alloc_scaled);
     }
 
-    assert(total_size != 0);
-    total_size = (size_t)((float)total_size * 1.05);
-    if (loh_size_known)
+    if (allocation_no_gc_loh > 0)
     {
-        assert(loh_size != 0);
-        loh_size = (size_t)((float)loh_size * 1.05);
-        assert(loh_size <= total_size);
-        allocation_no_gc_loh = (size_t)loh_size;
-        allocation_no_gc_soh = (size_t)(total_size - loh_size);
-    }
-    else
-    {
-        allocation_no_gc_soh = (size_t)total_size;
-        allocation_no_gc_loh = (size_t)total_size;
+        allocation_no_gc_loh = static_cast<uint64_t>(allocation_no_gc_loh * scale_factor);
+        allocation_no_gc_loh = min (allocation_no_gc_loh, total_allowed_loh_alloc_scaled);
     }
 
 
@@ -15943,9 +15949,11 @@ start_no_gc_region_status gc_heap::prepare_for_no_gc_region (uint64_t total_size
     if (disallow_full_blocking)
         current_no_gc_region_info.minimal_gc_p = TRUE;
 
+    size_t size_per_heap = 0;
     if (allocation_no_gc_soh != 0)
     {
-        current_no_gc_region_info.soh_allocation_size = allocation_no_gc_soh;
+        assert(allocation_no_gc_soh <= SIZE_T_MAX);
+        current_no_gc_region_info.soh_allocation_size = static_cast<size_t>(allocation_no_gc_soh);
         size_per_heap = current_no_gc_region_info.soh_allocation_size;
 #ifdef MULTIPLE_HEAPS
         size_per_heap /= n_heaps;
@@ -15961,7 +15969,8 @@ start_no_gc_region_status gc_heap::prepare_for_no_gc_region (uint64_t total_size
 
     if (allocation_no_gc_loh != 0)
     {
-        current_no_gc_region_info.loh_allocation_size = allocation_no_gc_loh;
+        assert(allocation_no_gc_soh <= SIZE_T_MAX);
+        current_no_gc_region_info.loh_allocation_size = static_cast<size_t>(allocation_no_gc_loh);
         size_per_heap = current_no_gc_region_info.loh_allocation_size;
 #ifdef MULTIPLE_HEAPS
         size_per_heap /= n_heaps;