Backport OCaml ocaml#13736 to 5.3.0-semgrep (#26)

## Summary

Backport [ocaml#13736](ocaml#13736) to `5.3.0-semgrep`.

Synchronous major collections advance the major GC work counter without corresponding allocation. After `Gc.major`, `Gc.full_major`, or `Gc.compact`, the work counter can therefore remain far ahead of the allocation counter, suppressing subsequent automatic major GC slices until allocation catches up. On a large heap this can cause rapid heap growth or OOM after an explicit collection.

The upstream fix resets the allocation and work counters to the same logical clock after synchronous major GC work. This is relevant to Semgrep because its memory-limit handler calls `Gc.compact` before reraising an OOM or memory-limit exception.

## Backport Notes

The three runtime changes apply to OCaml 5.3 without adaptation and match upstream ocaml#13736:

- Add `caml_reset_major_pacing`.
- Invoke it after explicit major collection work, including each `Gc.full_major` and `Gc.compact` cycle.
- Omit the conflicting upstream `Changes` entry, since this is a Semgrep-fork backport.

No compiler or Semgrep-specific code is changed.

## Validation

- Clean Flambda bootstrap of the exact branch:
  `./configure --enable-flambda && make -j8`
- Confirmed the resulting compiler reports `flambda: true`.
- Compiled an identical post-compaction pacing workload with unpatched and patched 5.3 runtimes. The workload compacts a 320 MiB live heap, drops it, and then performs short-lived major allocations:
  - Unpatched: reached the 768 MiB guard after 17,900 iterations; heap reached 801 MiB with only 2 automatic major cycles.
  - Patched: completed 100,000 iterations; final heap returned to 0 MiB with 10,169 automatic major cycles.

Author: dijkstracula

runtime/caml/major_gc.h

@@ -42,6 +42,11 @@ void caml_darken_cont(value);
 void caml_mark_root(value, value*);
 void caml_empty_mark_stack(void);
 void caml_finish_major_cycle(int force_compaction);
+/* Reset any internal accounting the GC uses to set collection pacing.
+ * For use at times when we have disturbed the usual pacing, for
+ * example, after any synchronous major collection.
+ */
+void caml_reset_major_pacing(void);
 #ifdef DEBUG
 int caml_mark_stack_is_empty(void);
 #endif

runtime/gc_ctrl.c

@@ -242,6 +242,7 @@ static caml_result gc_major_res(int force_compaction)
   caml_gc_log ("Major GC cycle requested");
   caml_empty_minor_heaps_once();
   caml_finish_major_cycle(force_compaction);
+  caml_reset_major_pacing();
   caml_result result = caml_process_pending_actions_res();
   CAML_EV_END(EV_EXPLICIT_GC_MAJOR);
   return result;
@@ -262,6 +263,7 @@ static caml_result gc_full_major_res(void)
      currently-unreachable object to be collected. */
   for (int i = 0; i < 3; i++) {
     caml_finish_major_cycle(0);
+    caml_reset_major_pacing();
     caml_result res = caml_process_pending_actions_res();
     if (caml_result_is_exception(res)) return res;
   }
@@ -297,6 +299,7 @@ CAMLprim value caml_gc_compaction(value v)
      why this needs three iterations. */
   for (int i = 0; i < 3; i++) {
     caml_finish_major_cycle(i == 2);
+    caml_reset_major_pacing();
     result = caml_process_pending_actions_res();
     if (caml_result_is_exception(result)) break;
   }

runtime/major_gc.c

@@ -576,6 +576,30 @@ static inline intnat diffmod (uintnat x1, uintnat x2)
   return (intnat) (x1 - x2);
 }
 
+/* Reset the work and alloc counters to be equal to each other, by
+ * setting them both equal to the "larger" (in the wrapping-around
+ * sense we are using here for work_counter and alloc_counter).
+ *
+ * For use at times when we have disturbed the major GC from its usual
+ * pacing and tempo, for example, after any synchronous major
+ * collection.
+ */
+
+void caml_reset_major_pacing(void)
+{
+  bool res;
+  do {
+    uintnat alloc = atomic_load(&alloc_counter);
+    uintnat work = atomic_load(&work_counter);
+    uintnat target = alloc;
+    if (diffmod(work, alloc) > 0) {
+      target = work;
+    }
+    res = (atomic_compare_exchange_strong(&alloc_counter, &alloc, target) &&
+           atomic_compare_exchange_strong(&work_counter, &work, target));
+  } while (!res);
+}
+
 /* The [log_events] parameter is used to disable writing to the ring for two
    reasons:
    1. To prevent spamming the ring with numerous events generated during