Name the explicit constants used with caml_verb_gc (runtime5) (#3584)

Name the explicit constants used with caml_verb_gc

Author: NickBarnes

runtime/caml/misc.h

@@ -503,19 +503,70 @@ CAMLextern int caml_read_directory(char_os * dirname,
 
 #ifdef CAML_INTERNALS
 
-/* GC flags and messages */
+/* runtime message flags. Settable with v= in OCAMLRUNPARAM */
 
 extern atomic_uintnat caml_verb_gc;
 
-void caml_gc_log (char *, ...)
-#ifdef __GNUC__
-  __attribute__ ((format (printf, 1, 2)))
+/* Bits which may be set in caml_verb_gc. The quotations are from the
+ * OCaml manual. */
+
+/* "Start and end of major GC cycle" (unused) */
+#define CAML_GC_MSG_MAJOR           0x0001
+/* "Minor collection and major GC slice" (unused) */
+#define CAML_GC_MSG_MINOR           0x0002
+/* "Growing and shrinking of the heap" */
+#define CAML_GC_MSG_HEAPSIZE        0x0004
+/* "Resizing of stacks and memory manager tables" */
+#define CAML_GC_MSG_STACKSIZE       0x0008
+/* "Heap compaction" (unused) */
+#define CAML_GC_MSG_COMPACT         0x0010
+/* "Change of GC parameters" */
+#define CAML_GC_MSG_PARAMS          0x0020
+/* "Computation of major GC slice size" */
+#define CAML_GC_MSG_SLICESIZE       0x0040
+/* "Calling of finalization functions" */
+#define CAML_GC_MSG_FINALIZE        0x0080
+/* "Startup messages" */
+#define CAML_GC_MSG_STARTUP         0x0100
+/* "Computation of compaction-triggering condition" (unused) */
+#define CAML_GC_MSG_COMPACT_TRIGGER 0x0200
+/* "Output GC statistics at program exit" */
+#define CAML_GC_MSG_STATS           0x0400
+/* "GC debugging messages */
+#define CAML_GC_MSG_DEBUG           0x0800
+/* "Address space reservation changes" */
+#define CAML_GC_MSG_ADDRSPACE       0x1000
+
+/* Default set of messages when runtime invoked with -v */
+
+#define CAML_GC_MSG_VERBOSE (CAML_GC_MSG_MAJOR     | \
+                             CAML_GC_MSG_HEAPSIZE  | \
+                             CAML_GC_MSG_STACKSIZE | \
+                             CAML_GC_MSG_COMPACT   | \
+                             CAML_GC_MSG_PARAMS)
+
+/* Use to control messages which should be output at any non-zero verbosity */
+
+#define CAML_GC_MSG_ANY (-1)
+
+/* output message if caml_verb_gc includes any bits in `category`. */
+
+void caml_gc_message (int category, const char *, ...)
+#if __has_attribute(format) || defined(__GNUC__)
+  __attribute__ ((format (printf, 2, 3)))
 #endif
 ;
 
-void caml_gc_message (int, char *, ...)
-#ifdef __GNUC__
-  __attribute__ ((format (printf, 2, 3)))
+/* Short-hand for calls to `caml_gc_message` */
+
+#define CAML_GC_MESSAGE(category, ...) \
+    caml_gc_message(CAML_GC_MSG_ ## category, __VA_ARGS__)
+
+/* Output message if CAML_GC_MSG_DEBUG is set */
+
+void caml_gc_log (const char *, ...)
+#if __has_attribute(format) || defined(__GNUC__)
+  __attribute__ ((format (printf, 1, 2)))
 #endif
 ;
 

runtime/compare.c

@@ -51,7 +51,7 @@ static void compare_free_stack(struct compare_stack* stk)
 /* Same, then raise Out_of_memory */
 CAMLnoret static void compare_stack_overflow(struct compare_stack* stk)
 {
-  caml_gc_message (0x04, "Stack overflow in structural comparison\n");
+  CAML_GC_MESSAGE(HEAPSIZE, "Stack overflow in structural comparison\n");
   compare_free_stack(stk);
   caml_raise_out_of_memory();
 }

runtime/dynlink.c

@@ -144,7 +144,7 @@ static void open_shared_lib(char_os * name)
 
   realname = caml_search_dll_in_path(&caml_shared_libs_path, name);
   u8 = caml_stat_strdup_of_os(realname);
-  caml_gc_message(0x100, "Loading shared library %s\n", u8);
+  CAML_GC_MESSAGE(STARTUP, "Loading shared library %s\n", u8);
   caml_stat_free(u8);
   caml_enter_blocking_section();
   handle = caml_dlopen(realname, 1);
@@ -311,7 +311,7 @@ CAMLprim value caml_dynlink_open_lib(value mode, value filename)
   value result;
   char_os * p;
 
-  caml_gc_message(0x100, "Opening shared library %s\n",
+  CAML_GC_MESSAGE(STARTUP, "Opening shared library %s\n",
                   String_val(filename));
   p = caml_stat_strdup_to_os(String_val(filename));
   caml_enter_blocking_section();

runtime/extern.c

@@ -470,7 +470,8 @@ static void extern_failwith(struct caml_extern_state* s, char *msg)
 
 static void extern_stack_overflow(struct caml_extern_state* s)
 {
-  caml_gc_message (0x04, "Stack overflow in marshaling value\n");
+  CAML_GC_MESSAGE(HEAPSIZE,
+                  "Stack overflow in marshaling value\n");
   free_extern_output(s);
   caml_raise_out_of_memory();
 }

runtime/finalise.c

@@ -151,7 +151,8 @@ value caml_final_do_calls_exn(void)
   if (fi->running_finalisation_function) return Val_unit;
   if (fi->todo_head != NULL) {
     call_timing_hook(&caml_finalise_begin_hook);
-    caml_gc_message (0x80, "Calling finalisation functions.\n");
+    CAML_GC_MESSAGE(FINALIZE,
+                    "Calling finalisation functions.\n");
     while (1) {
       while (fi->todo_head != NULL && fi->todo_head->size == 0) {
         struct final_todo *next_head = fi->todo_head->next;
@@ -168,7 +169,8 @@ value caml_final_do_calls_exn(void)
       fi->running_finalisation_function = 0;
       if (Is_exception_result(res)) return res;
     }
-    caml_gc_message (0x80, "Done calling finalisation functions.\n");
+    CAML_GC_MESSAGE(FINALIZE,
+                    "Done calling finalisation functions.\n");
     call_timing_hook(&caml_finalise_end_hook);
   }
   return Val_unit;

runtime/gc_ctrl.c

@@ -187,14 +187,15 @@ CAMLprim value caml_gc_set(value v)
 
   if (newpf != caml_percent_free){
     caml_percent_free = newpf;
-    caml_gc_message (0x20, "New space overhead: %"
-                     ARCH_INTNAT_PRINTF_FORMAT "u%%\n", caml_percent_free);
+    CAML_GC_MESSAGE(PARAMS,
+                    "New space overhead: %" ARCH_INTNAT_PRINTF_FORMAT "u%%\n",
+                    caml_percent_free);
   }
 
   if (newpm != caml_max_percent_free) {
     caml_max_percent_free = newpm;
-    caml_gc_message (0x20, "New max space overhead: %"
-                     ARCH_INTNAT_PRINTF_FORMAT "u%%\n", caml_max_percent_free);
+    CAML_GC_MESSAGE(PARAMS, "New max space overhead: %"
+                    ARCH_INTNAT_PRINTF_FORMAT "u%%\n", caml_max_percent_free);
   }
 
   atomic_store_relaxed(&caml_verb_gc, new_verb_gc);
@@ -203,29 +204,29 @@ CAMLprim value caml_gc_set(value v)
   if (Wosize_val (v) >= 11){
     if (new_custom_maj != caml_custom_major_ratio){
       caml_custom_major_ratio = new_custom_maj;
-      caml_gc_message (0x20, "New custom major ratio: %"
-                       ARCH_INTNAT_PRINTF_FORMAT "u%%\n",
-                       caml_custom_major_ratio);
+      CAML_GC_MESSAGE(PARAMS, "New custom major ratio: %"
+                      ARCH_INTNAT_PRINTF_FORMAT "u%%\n",
+                      caml_custom_major_ratio);
     }
     if (new_custom_min != caml_custom_minor_ratio){
       caml_custom_minor_ratio = new_custom_min;
-      caml_gc_message (0x20, "New custom minor ratio: %"
-                       ARCH_INTNAT_PRINTF_FORMAT "u%%\n",
-                       caml_custom_minor_ratio);
+      CAML_GC_MESSAGE(PARAMS, "New custom minor ratio: %"
+                      ARCH_INTNAT_PRINTF_FORMAT "u%%\n",
+                      caml_custom_minor_ratio);
     }
     if (new_custom_sz != caml_custom_minor_max_bsz){
       caml_custom_minor_max_bsz = new_custom_sz;
-      caml_gc_message (0x20, "New custom minor size limit: %"
-                       ARCH_INTNAT_PRINTF_FORMAT "u%%\n",
-                       caml_custom_minor_max_bsz);
+      CAML_GC_MESSAGE(PARAMS, "New custom minor size limit: %"
+                      ARCH_INTNAT_PRINTF_FORMAT "u%%\n",
+                      caml_custom_minor_max_bsz);
     }
   }
 
   /* Minor heap size comes last because it will trigger a minor collection
      (thus invalidating [v]) and it can raise [Out_of_memory]. */
   if (newminwsz != Caml_state->minor_heap_wsz) {
-    caml_gc_message (0x20, "New minor heap size: %"
-                     ARCH_INTNAT_PRINTF_FORMAT "uk words\n", newminwsz / 1024);
+    CAML_GC_MESSAGE(PARAMS, "New minor heap size: %"
+                    ARCH_INTNAT_PRINTF_FORMAT "uk words\n", newminwsz / 1024);
   }
 
   if (newminwsz > caml_minor_heap_max_wsz) {
@@ -388,25 +389,6 @@ void caml_init_gc (void)
   caml_percent_free = norm_pfree (percent_fr);
   caml_max_percent_free = norm_pmax (percent_m);
   caml_init_major_heap (major_heap_size);
-  caml_gc_message (0x20, "Initial minor heap size: %luk bytes\n",
-                   Caml_state->minor_heap_size / 1024);
-  caml_gc_message (0x20, "Initial major heap size: %luk bytes\n",
-                   major_heap_size / 1024);
-  caml_gc_message (0x20, "Initial space overhead: %"
-                   ARCH_INTNAT_PRINTF_FORMAT "u%%\n", caml_percent_free);
-  caml_gc_message (0x20, "Initial max overhead: %"
-                   ARCH_INTNAT_PRINTF_FORMAT "u%%\n", caml_max_percent_free);
-  if (caml_major_heap_increment > 1000){
-    caml_gc_message (0x20, "Initial heap increment: %"
-                     ARCH_INTNAT_PRINTF_FORMAT "uk words\n",
-                     caml_major_heap_increment / 1024);
-  }else{
-    caml_gc_message (0x20, "Initial heap increment: %"
-                     ARCH_INTNAT_PRINTF_FORMAT "u%%\n",
-                     caml_major_heap_increment);
-  }
-  caml_gc_message (0x20, "Initial allocation policy: %d\n",
-                   caml_allocation_policy);
 */
 }
 

runtime/intern.c

@@ -337,7 +337,7 @@ static void readfloats(struct caml_intern_state* s,
 
 CAMLnoret static void intern_stack_overflow(struct caml_intern_state* s)
 {
-  caml_gc_message (0x04, "Stack overflow in un-marshaling value\n");
+  CAML_GC_MESSAGE(HEAPSIZE, "Stack overflow in un-marshaling value\n");
   intern_cleanup(s);
   caml_raise_out_of_memory();
 }

runtime/major_gc.c

@@ -702,36 +702,36 @@ static void update_major_slice_work(intnat howmuch,
 
   extra_work = (intnat) (my_extra_count * (double) total_cycle_work);
 
-  caml_gc_message (0x40, "heap_words = %"
-                         ARCH_INTNAT_PRINTF_FORMAT "u\n",
-                   (uintnat)heap_words);
-  caml_gc_message (0x40, "allocated_words = %"
-                         ARCH_INTNAT_PRINTF_FORMAT "u\n",
+  CAML_GC_MESSAGE(SLICESIZE,
+                  "heap_words = %" ARCH_INTNAT_PRINTF_FORMAT "u\n",
+                  (uintnat)heap_words);
+  CAML_GC_MESSAGE(SLICESIZE,
+                  "allocated_words = %" ARCH_INTNAT_PRINTF_FORMAT "u\n",
                    my_alloc_count);
-  caml_gc_message (0x40, "allocated_words_direct = %"
-                         ARCH_INTNAT_PRINTF_FORMAT "u\n",
+  CAML_GC_MESSAGE(SLICESIZE,
+                  "allocated_words_direct = %" ARCH_INTNAT_PRINTF_FORMAT "u\n",
                    my_alloc_direct_count);
-  caml_gc_message (0x40, "alloc work-to-do = %"
-                         ARCH_INTNAT_PRINTF_FORMAT "d\n",
+  CAML_GC_MESSAGE(SLICESIZE,
+                  "alloc work-to-do = %" ARCH_INTNAT_PRINTF_FORMAT "d\n",
                    alloc_work);
-  caml_gc_message (0x40, "dependent_words = %"
-                         ARCH_INTNAT_PRINTF_FORMAT "u\n",
+  CAML_GC_MESSAGE(SLICESIZE,
+                  "dependent_words = %" ARCH_INTNAT_PRINTF_FORMAT "u\n",
                    my_dependent_count);
-  caml_gc_message (0x40, "dependent work-to-do = %"
-                         ARCH_INTNAT_PRINTF_FORMAT "d\n",
-                   dependent_work);
-  caml_gc_message (0x40, "extra_heap_resources = %"
-                         ARCH_INTNAT_PRINTF_FORMAT "uu\n",
-                   (uintnat) (my_extra_count * 1000000));
-  caml_gc_message (0x40, "extra work-to-do = %"
-                         ARCH_INTNAT_PRINTF_FORMAT "d\n",
-                   extra_work);
+  CAML_GC_MESSAGE(SLICESIZE,
+                  "dependent work-to-do = %" ARCH_INTNAT_PRINTF_FORMAT "d\n",
+                  dependent_work);
+  CAML_GC_MESSAGE(SLICESIZE,
+                  "extra_heap_resources = %" ARCH_INTNAT_PRINTF_FORMAT "uu\n",
+                  (uintnat) (my_extra_count * 1000000));
+  CAML_GC_MESSAGE(SLICESIZE,
+                  "extra work-to-do = %" ARCH_INTNAT_PRINTF_FORMAT "d\n",
+                  extra_work);
 
   intnat offheap_work = max2 (dependent_work, extra_work);
   intnat clamp = alloc_work * caml_custom_work_max_multiplier;
   if (offheap_work > clamp) {
-    caml_gc_message(0x40, "Work clamped to %"
-                          ARCH_INTNAT_PRINTF_FORMAT "d\n",
+    CAML_GC_MESSAGE(SLICESIZE, "Work clamped to %"
+                    ARCH_INTNAT_PRINTF_FORMAT "d\n",
                     clamp);
     offheap_work = clamp;
   }
@@ -1456,21 +1456,21 @@ static bool should_compact_from_stw_single(int compaction_mode)
   if (compaction_mode == Compaction_none) {
     return false;
   } else if (compaction_mode == Compaction_forced) {
-    caml_gc_message (0x200, "Forced compaction.\n");
+    CAML_GC_MESSAGE (COMPACT_TRIGGER, "Forced compaction.\n");
     return true;
   }
   CAMLassert (compaction_mode == Compaction_auto);
 
   /* runtime 4 algorithm, as close as possible.
    * TODO: revisit this in future. */
   if (caml_max_percent_free >= 1000 * 1000) {
-    caml_gc_message (0x200,
+    CAML_GC_MESSAGE (COMPACT_TRIGGER,
                      "Max percent free %"ARCH_INTNAT_PRINTF_FORMAT"u%%:"
                      "compaction off.\n", caml_max_percent_free);
     return false;
   }
   if (caml_major_cycles_completed < 3) {
-    caml_gc_message (0x200,
+    CAML_GC_MESSAGE (COMPACT_TRIGGER,
                      "Only %"ARCH_INTNAT_PRINTF_FORMAT"u major cycles: "
                      "compaction off.\n", caml_major_cycles_completed);
     return false;
@@ -1489,7 +1489,7 @@ static bool should_compact_from_stw_single(int compaction_mode)
   double current_overhead = 100.0 * free_words / live_words;
 
   bool compacting = current_overhead >= caml_max_percent_free;
-  caml_gc_message (0x200, "Current overhead: %"
+  CAML_GC_MESSAGE (COMPACT_TRIGGER, "Current overhead: %"
                    ARCH_INTNAT_PRINTF_FORMAT "u%% %s %"
                    ARCH_INTNAT_PRINTF_FORMAT "u%%: %scompacting.\n",
                    (uintnat) current_overhead,
@@ -1511,9 +1511,9 @@ static void cycle_major_heap_from_stw_single(
               (long unsigned int)caml_major_cycles_completed);
 
   caml_major_cycles_completed++;
-  caml_gc_message(0x40, "Starting major GC cycle\n");
+  CAML_GC_MESSAGE(SLICESIZE, "Starting major GC cycle\n");
 
-  if (atomic_load_relaxed(&caml_verb_gc) & 0x400) {
+  if (atomic_load_relaxed(&caml_verb_gc) & CAML_GC_MSG_STATS) {
     struct gc_stats s;
     intnat heap_words, not_garbage_words, swept_words;
 
@@ -1789,8 +1789,9 @@ static void major_collection_slice(intnat howmuch,
   /* Opportunistic slices may run concurrently with gc phase updates. */
   int may_access_gc_phase = (mode != Slice_opportunistic);
 
-  bool log_events = (mode != Slice_opportunistic ||
-                     (atomic_load_relaxed(&caml_verb_gc) & 0x40));
+  bool log_events = mode != Slice_opportunistic ||
+                    (atomic_load_relaxed(&caml_verb_gc) &
+                     CAML_GC_MSG_SLICESIZE);
 
   update_major_slice_work(howmuch, may_access_gc_phase, log_events);
 

runtime/memory.c

@@ -590,7 +590,7 @@ void caml_local_realloc(void)
   for (i = s->saved_sp; i < 0; i += sizeof(value)) {
     *((header_t*)(arena + s->next_length + i)) = Local_uninit_hd;
   }
-  caml_gc_message(0x08,
+  CAML_GC_MESSAGE(STACKSIZE,
                   "Growing local stack to %"ARCH_INTNAT_PRINTF_FORMAT"d kB\n",
                   s->next_length / 1024);
   s->count++;

runtime/meta.c

@@ -150,7 +150,7 @@ CAMLprim value caml_realloc_global(value size)
   actual_size = Wosize_val(old_global_data);
   if (requested_size >= actual_size) {
     requested_size = (requested_size + 0x100) & 0xFFFFFF00;
-    caml_gc_message (0x08, "Growing global data to %"
+    CAML_GC_MESSAGE(STACKSIZE, "Growing global data to %"
                      ARCH_INTNAT_PRINTF_FORMAT "u entries\n",
                      requested_size);
     new_global_data = caml_alloc_shr(requested_size, 0);