Use the same threshold for out-of-cycle work for major and minor dependent allocs (#3616)

Use the same threshold for out-of-cycle work for major and minor dep alloc

(Squashes a FIXME)

Author: stedolan

runtime/caml/custom.h

@@ -89,9 +89,6 @@ CAMLextern value caml_alloc_custom_dep(const struct custom_operations * ops,
 CAMLextern void
           caml_register_custom_operations(const struct custom_operations * ops);
 
-/* Return the current [max] factor for [caml_alloc_custom_mem] allocations. */
-CAMLextern mlsize_t caml_custom_get_max_major (void);
-
 /* Global variable moved to Caml_state in 4.10 */
 #define caml_compare_unordered (Caml_state_field(compare_unordered))
 

runtime/custom.c

@@ -36,22 +36,6 @@ uintnat caml_custom_major_ratio = Custom_major_ratio_def;
 uintnat caml_custom_minor_ratio = Custom_minor_ratio_def;
 uintnat caml_custom_minor_max_bsz = Custom_minor_max_bsz_def;
 
-mlsize_t caml_custom_get_max_major (void)
-{
-  /* The major ratio is a percentage relative to the major heap size.
-     A complete GC cycle will be done every time 2/3 of that much
-     memory is allocated for blocks in the major heap.  Assuming
-     constant allocation and deallocation rates, this means there are
-     at most [M/100 * major-heap-size] bytes of floating garbage at
-     any time.  The reason for a factor of 2/3 (or 1.5) is, roughly
-     speaking, because the major GC takes 1.5 cycles (previous cycle +
-     marking phase) before it starts to deallocate dead blocks
-     allocated during the previous cycle.  [heap_size / 150] is really
-     [heap_size * (2/3) / 100] (but faster). */
-  return caml_heap_size(Caml_state->shared_heap) / 150
-         * caml_custom_major_ratio;
-}
-
 static value alloc_custom_gen (const struct custom_operations * ops,
                                uintnat bsz,
                                bool minor_ok,

runtime/major_gc.c

@@ -633,10 +633,22 @@ static void update_major_slice_work(intnat howmuch,
 
   my_alloc_count = dom_st->allocated_words;
   my_alloc_direct_count = dom_st->allocated_words_direct;
-  my_extra_count =
-    (double)dom_st->allocated_dependent_bytes /
-    (double)caml_custom_get_max_major ();
-  if (my_extra_count > 1.0) my_extra_count = 1.0;
+  {
+    /* The major ratio is a percentage relative to the major heap size.
+       A complete GC cycle will be done every time 2/3 of that much
+       memory is allocated for blocks in the major heap.  Assuming
+       constant allocation and deallocation rates, this means there are
+       at most [M/100 * major-heap-size] bytes of floating garbage at
+       any time.  The reason for a factor of 2/3 (or 1.5) is, roughly
+       speaking, because the major GC takes 1.5 cycles (previous cycle +
+       marking phase) before it starts to deallocate dead blocks
+       allocated during the previous cycle.  [heap_size / 150] is really
+       [heap_size * (2/3) / 100] (but faster). */
+    double max_major =
+      caml_heap_size(Caml_state->shared_heap) / 150 * caml_custom_major_ratio;
+    my_extra_count = (double)dom_st->allocated_dependent_bytes / max_major;
+    if (my_extra_count > 1.0) my_extra_count = 1.0;
+  }
   dom_st->stat_major_words += dom_st->allocated_words;
   dom_st->allocated_words = 0;
   dom_st->allocated_words_direct = 0;

runtime/memory.c

@@ -240,21 +240,20 @@ CAMLexport void caml_alloc_dependent_memory (value v, mlsize_t nbytes)
 {
   if (nbytes == 0) return;
   CAMLassert (Is_block (v));
+  /* Maximum dependent allocation before a minor GC or a major slice */
+  uintnat max_alloc =
+    Bsize_wsize (Caml_state->minor_heap_wsz) / 100 * caml_custom_minor_ratio;
   if (Is_young (v)){
     Caml_state->stat_minor_dependent_bytes += nbytes;
     add_to_dependent_table (&Caml_state->minor_tables->dependent, v, nbytes);
     Caml_state->minor_dependent_bsz += nbytes;
-    uintnat max_minor =
-      Bsize_wsize (Caml_state->minor_heap_wsz) / 100 * caml_custom_minor_ratio;
-    if (Caml_state->minor_dependent_bsz > max_minor) {
+    if (Caml_state->minor_dependent_bsz > max_alloc) {
       caml_request_minor_gc ();
     }
   } else {
     caml_add_dependent_bytes (Caml_state->shared_heap, nbytes);
     Caml_state->allocated_dependent_bytes += nbytes;
-    /* FIXME sdolan: what's the right condition here? */
-    uintnat max_major = caml_custom_get_max_major() / 5;
-    if (Caml_state->allocated_dependent_bytes > max_major){
+    if (Caml_state->allocated_dependent_bytes > max_alloc){
       CAML_EV_COUNTER (EV_C_REQUEST_MAJOR_ALLOC_SHR, 1);
       caml_request_major_slice(1);
     }