Multicore OCaml: July 2020

Welcome to the July 2020 Multicore OCaml report! This update, along with the previous updates, has been compiled by @shakthimaan, @kayceesrk and myself. There are a number of advances both in upstream OCaml as well as our multicore trees.

Multicore OCaml

Thread compatibility via Domain Execution Contexts

TL;DR: once #381 is merged, dune will work with multicore OCaml.

As I noted last month, not having a Thread module that is backwards compatible with traditional OCaml’s is a big blocker for ecosystem compatibility. This can be a little confusing at first glance – why does Multicore OCaml need non-parallel threading support? The answer lies in the relationship between concurrency and parallelism in multicore OCaml. Concurrency is how we partition multiple computations such that they run in overlapping time periods, and parallelism is how we run them on separate cores simultaneously to gain greater performance. A number of packages (most notably, Dune) currently use the Thread module to conveniently gain concurrency while writing straight-line code without using monadic abstractions. These uses do not require parallelism, but are very difficult to rewrite to not use thread-based concurrency.

Therefore, multicore OCaml also needs a way to provide a reasonably performant version of Thread. The first solution we attempted (started by @jhw and continued by @engil in #342) mapped a Thread to a multicore Domain, but scaled poorly for a larger number of threads since we may have a far greater number of concurrency contexts (Thread instances) than we have CPUs available (Domain instances). This lead to a bit of brainstorming (#357) to figure out a solution that would work for applications like Dune or the XenServer stack that are heavy Thread users.

Our solution introduces a concept that we have dubbed Domain Execution Contexts in #381, which allows us to map multiple system threads to OCaml domains. Once that PR is reviewed and merged into the multicore OCaml branches, it will unlock many more ecosystem packages, as the Dune build system will compile unmodified. The last “big” remaining blocker for wider opam testing after this is then ocaml-migrate-parsetree, which requires a small patch to support the effect keyword syntax that is present in the multicore OCaml trees.

Domain Local Storage

Domain Local Storage (DLS) (#372) is a simple way to attach OCaml values privately to a domain. A good example of speedup when using DLS is shown in a PR to the LU decomposition benchmark. In this case, the benchmark needs a lot of random numbers, and initialising them in parallel locally to the domain is a win.

Another example is the parallel implementation of an evolutionary algorithm (originally suggested by @per_kristian_lehre in #336) which speeds up nicely in #151 (for those who want to check the baseline, there is a sequential version in #155 that you can look up in the Sandmark web interface).

Parallel Programming with Multicore OCaml (document)

A tutorial on Parallel Programming with Multicore OCaml has been made available. It provides an introduction to Multicore OCaml and explains the concepts of Domains, Domainslib, and Channels. Profiling of OCaml code using perf and Eventlog are also illustrated with examples.

This draft was shared on Reddit as well as on HackerNews, so you’ll find more chatter about it there.

Coq benchmarks

The Sandmark benchmarking suite for OCaml has been successfully updated to use dune.2.6.0 and builds for Multicore OCaml 4.10.0. With this major upgrade, we have also been able to include Coq and its
dependencies. We are working on adding more regression Coq benchmarks to the test suite.

Upstream OCaml

The upstream OCaml trees have seen a flurry of activity in the 4.12.0dev trees with changes to prepare for multicore OCaml. The biggest one is the (to quote @xavierleroy) fabled page-less compactor in ocaml/ocaml#9728. This followed on from last month’s work (#9698) to eliminate the use of the page table when the compiler is built with the “no-naked-pointers” option, and clears the path for the parallel multicore OCaml runtime to be integrated in a future release of OCaml.

One of the other changes we hope to get into OCaml 4.12 is the alignment of the use of garbage collector colours when marking and sweeping. The #9756 changes make the upstream runtime use the same scheme we described in the Retrofitting Parallelism onto OCaml ICFP paper, with a few extra improvements that you can read about in the PR review comments.

If you are curious about the full set of changes, you can see all the multicore prerequisite issues that have been closed to date upstream.

Detailed Updates

As with the previous updates, the Multicore OCaml updates are first listed, which are then followed by the enhancements to the Sandmark benchmarking project. The upstream OCaml ongoing and completed updates are finally mentioned for your reference.

Multicore OCaml


  • ocaml-multicore/ocaml-multicore#342
    Implementing the threads library with Domains

    This is an on-going effort to rebase @jhwoodyatt’s implementation of the Thread
    library for Domains.

  • ocaml-multicore/ocaml-multicore#357
    Implementation of systhreads with pthreads

    A Domain Execution Context (DEC) is being introduced in this
    implementation as a concurrency abstraction for implementing
    systhreads with pthreads.

  • ocaml-multicore/ocaml-multicore#374
    Force major slice on minor collection

    A blocked thread in a domain may not progress the major GC when
    servicing the minor collector through handle_interrupt, and hence
    we need to have a minor collection to schedule a major collection


Domain-Local State

Removal of vestiges in Concurrent Minor GC

  • ocaml-multicore/ocaml-multicore#370
    Remove Cloadmut and lloadmut

    The Cloadmut and Iloadmut implementation and usage have been
    cleaned up with this patch. This simplifies the code and brings it
    closer to stock OCaml.

  • ocaml-multicore/ocaml-multicore#371
    Domain interrupt cleanup

    In runtime/domain.c the struct interruptor* sender has been
    removed. The domain RPC functions have been grouped together in
    domain.h, and consistent naming of definitions have been applied.

Code Cleanup


  • ocaml-multicore/ocaml-multicore#366
    Add event to record idle domains

    The domain/idle_wait and domain/send_interrupt events are added
    to track domains that are idling. An eventlog screenshot with this
    effect is shown below:

  • ocaml-multicore/ocaml-multicore#369
    Split caml_urge_major_slice into caml_request_minor_gc and

    The caml_urge_major_slices is split into caml_request_minor_gc
    and caml_request_major_slice. This reduces the total number of
    minor garbage collections as observed in the following illustration:

  • ocaml-multicore/ocaml-multicore#373
    Fix the opam pin command in case the current directory name has spaces

    Use the -k path command-line argument with opam pin to handle
    directory names that have whitespaces.

  • ocaml-multicore/ocaml-multicore#375
    Only lock the global freelist to adopt pools if needed

    The lock acquire and release on allocation is removed when there are
    no global pools requiring adoption.

  • ocaml-multicore/ocaml-multicore#377
    Group env vars for run in travis CI

    The OCAMLRUNPARAM parameter is defined as part of the environment
    variable with the USE_RUNTIME=d command.

  • ocaml/dune#3608
    Upstream Multicore dune bootstrap patch

    The patch is used to build dune using the secondary compiler
    approach for



  • ocaml-bench/sandmark#107
    Add Coq benchmarks

    The upgrade of Sandmark to use dune.2.6.0 for Multicore OCaml 4.10.0
    has allowed us to install Coq and its dependencies. We are currently
    working on adding more Coq regression benchmarks to Sandmark.

  • ocaml-bench/sandmark#122
    Measurements of code size

    The code size of a benchmark is one measurement that is required for
    flambda branch, and we are exploring adding the same to the
    Sandmark bench runs.

  • ocaml-bench/sandmark#142
    [RFC] How should a user configure a sandmark run?

    We are gathering user feedback and suggestions on how you would like
    to configure benchmarking for Sandmark. Please share your thoughts
    and comments in this discussion.

  • ocaml-bench/sandmark#150
    Coq files that work

    Addition of more Coq files for benchmarking in Sandmark.


Dune 2.6.0 Upgrade

  • ocaml-bench/sandmark#131
    Update decompress benchmarks

    The decompress benchmarks were updated by @dinosaure to use the
    latest decompress.1.1.0 for dune.2.6.0.

  • ocaml-bench/sandmark#132
    Update dependency packages to use dune.2.6.0 and Multicore OCaml 4.10.0

    Sandmark has now been updated to use dune.2.6.0 and Multicore OCaml
    4.10.0 with an upgrade of over 30 dependency packages. You can test
    the same using:

    $ opam install dune.2.6.0
    $ make ocaml-versions/4.10.0+multicore.bench

Coq Benchmarks

Continuous Integration

  • ocaml-bench/sandmark#136
    Use BUILD_ONLY in .drone.yml

    The .drone.yml file has been updated to use a BUILD_ONLY environment
    variable to just install the dependencies and not execute the
    benchmarks for the CI.

  • ocaml-bench/sandmark#147
    Add support to associate tags with benchmarks

    The macro_bench and run_in_ci tags have been introduced to
    associate with the benchmarks. The benchmarks tagged as run_in_ci
    will be executed as part of the Sandmark CI.


  • ocaml-bench/sandmark#124
    User configurable paramwrapper added to Makefile

    The --cpu-list can now be specified as a PARAMWRAPPER
    environment variable for running the parallel benchmarks.

  • ocaml-bench/sandmark#134
    Include more info on README

    The README has been updated to include documentation to reflect the
    latest changes in Sandmark.

  • ocaml-bench/sandmark#141
    Enrich the variants with additional options

    The ocaml-versions/* files now use a JSON file format which allow
    you to specify the ocaml-base-compiler source URL, configure
    options and OCAMLRUNPARAMS. An example is provided below:

      "url" : "",
      "configure" : "-q",
      "runparams" : "v=0x400"
  • ocaml-bench/sandmark#146
    Update trunk from 4.11.0 to 4.12.0

    Sandmark now uses the latest stock OCaml 4.12.0 as trunk in

  • ocaml-bench/sandmark#148
    Install python3-pip and intervaltree for clean CI build

    The .drone.yml file has been updated to install python3-pip and
    intervaltree software packages to avoid errors when the Makefile
    is invoked.



  • ocaml/ocaml#9722
    EINTR-based signals, again

    The patch provides a new implementation to solve locking and
    signal-handling issues.

  • ocaml/ocaml#9756
    Garbage collector colours change

    The PR removes the gray colour in the garbage collector (GC) colour
    scheme in order to use it with the Multicore OCaml major collector.


  • ocaml/dune#3576
    In OCaml 4.12.0, empty archives no longer generate .a files

    A native archive will never be generated for an empty library, and
    this fixes the compatibility with OCaml 4.12.0 when dealing with
    empty archives.

  • ocaml/ocaml#9541
    Add manual page for the instrumented runtime

    The manual/manual/cmds/instrumented-runtime.etex document has been
    updated based on review comments and has been merged to stock OCaml.

  • ocaml/ocaml#9728
    Simplified compaction without page table

    A self-describing closure representation is used to simplify the
    compactor, and to get rid of the page table.

We would like to thank all the OCaml developers and users in the community for their continued support, code reviews, documentation and contributions to the multicore OCaml project.


  • CI: Continuous Integration
  • DEC: Domain Execution Context
  • GC: Garbage Collector
  • OPAM: OCaml Package Manager
  • PR: Pull Request
  • RFC: Request for Comments
  • RPC: Remote Procedure Call

Shouldn’t be “EINTR-based signals” task moved from Ongoing to Complete since it was merged a few days ago (July 29 to be precise)?

1 Like

How long until it’s implemented?