Which GC behavior limits parallel scaling in OCaml 5.0 Domains?

Answer to the core question

The bottleneck in OCaml 5.0’s parallel GC is the global Stop‑the‑World (STW) pause that precedes the marking phase. All domains must synchronize on the same shared heap, and the marking algorithm, although parallel, still requires a consistent view of the heap metadata. This synchronization introduces a global pause that limits scaling as the number of domains grows.

What the GC actually does

• All domains share one heap; no per‑domain allocation buffers exist.
• When a GC cycle starts, the runtime performs a STW barrier: every domain stops executing until the GC can safely walk the heap.
• Marking is then carried out in parallel by worker threads, but they must coordinate on shared bitmap and reference tables, which involves atomic operations and locks.
• After marking, sweeping is also performed on the same heap, again requiring a STW pause.

Impact on scaling

Because each GC cycle forces all domains to halt, the pause time does not shrink proportionally to the number of domains. In practice, the pause grows roughly linearly with the amount of live data that must be scanned, and the overhead of contention on shared metadata can add a non‑negligible constant cost per domain. Consequently, adding more domains beyond a small handful often yields diminishing returns.

Can the GC be tuned to reduce contention?

There are a few runtime knobs that influence GC behaviour:

• OCAMLRUNPARAM=v – enables verbose GC output, useful for measuring pause times.
• OCAMLRUNPARAM=g – sets the GC threshold for triggering a collection.
• OCAMLRUNPARAM=I – controls the size of the internal allocation buffer.

However, these knobs only affect the frequency of GC cycles or the size of the allocation buffer; they do not change the fact that a STW pause is required before marking. In other words, you can reduce the number of pauses or the amount of work per pause, but you cannot eliminate the global synchronization.

Is there a documented heap‑size threshold?

At present, the OCaml 5.0 documentation does not specify a hard heap‑size limit that triggers a noticeable drop in parallel GC performance. The behaviour is highly workload‑dependent: a small heap with frequent allocations can cause many short pauses, while a large heap with sparse allocations may see fewer, longer pauses. The only reliable way to understand the impact for a specific application is to benchmark with realistic workloads and measure pause durations using OCAMLRUNPARAM=v and profiling tools.

What to do next?

To decide whether the current GC behaviour is a problem for your application, run a simple benchmark that allocates objects in multiple domains and records pause times. If you notice that a single domain’s allocation rate is triggering global pauses that stall other domains, consider redesigning the workload to reduce per‑domain allocation pressure or splitting the application into fewer domains.

Diagnostic question

Could you share the typical allocation rate per domain in your application (e.g., objects per second)? Knowing that would help target whether tuning OCAMLRUNPARAM or restructuring the domain usage is the most effective approach.