The official OCaml documentation “Interfacing C with OCaml” doesn’t document some interesting performance features.

C functions with no OCaml allocation

A C call can allocate OCaml data and pass it back to OCaml, for example using caml_copy_string(s) . Between the C call allocating OCaml data and passing it back, it has to make sure that OCaml’s Garbage Collector doesn’t collect it, as the Garbage Collector can be triggered during the C call. There’s an intricate mechanism which assures that, part of which are CAMLparam, CAMLlocal and CAMLreturn.

This mechanism can be bypassed if the C call is not going to allocate any OCaml data. This can yield performance benefits especially in shorter functions. To bypass it, CAMLparam, CAMLlocal and CAMLreturn should not be used and the primitive should be declared with “noalloc”.

For example, OCaml’s compare is not smart to avoid branch mispredictions for floats. Moving comparison to C speeds it up a little bit. “noalloc” speeds it up a lot.

float compare 8.93 ns float_compare_c 7.88 ns float_compare_c_noalloc 5.32 ns external float_compare_noalloc : float -> float -> int = "float_compare_noalloc_stub" "noalloc" CAMLprim value float_compare_noalloc_stub(value vf, value vg) { double f = Double_val(vf); double g = Double_val(vg); return Val_int((f > g) - (f < g) + (f == f) - (g == g)); }

C functions with float arguments and float return

Since C code must use boxed OCaml floats, any unboxed float must be boxed prior to the C call. This is not cheap, especially for fast functions. This boxing can be avoided if the C call accepts and returns only floats.

For example, float_min can be replaced with a single CPU instruction. Unfortunately, the C implementation is much slower because of boxing floats:

float_min 6.09 ns float_min_c 15.92 ns let float_min (x : float) y = if x < y then x else y CAMLprim value float_min_stub(value x, value y) { CAMLparam2(x, y); CAMLlocal1(v); double z = Double_val(y); __asm__ ("minsd %1, %0;" : "+&x"(z) : "x"(Double_val(x))); v = caml_copy_double(z); CAMLreturn(v); } external float_min_c : float -> float -> float = "float_min_stub"

To avoid boxing, C function’s arguments and return should be “double”, CAMLparam, CAMLlocal and CAMLreturn should be avoided and the primitive should include “float” and both interpreted and compiled implementation:

float_min_c_float 1.95 ns external float_min_inan_c_float : float -> float -> float = "float_min_inan_float_bytecode" "float_min_inan_float_stub" "float" CAMLprim double float_min_inan_float_stub(double x, double y) { double z = y; __asm__ ("minsd %1, %0;" : "+&x"(z) : "x"(x)); return z; }

C functions with float arguments and non-float return

We might be able to further speed up float_compare_noalloc if we avoided boxing. Alas, that function returns integer so it’s impossible to use “float”. Is it still possible to avoid boxing? The answer is yes, by simply converting float to int.