Fast paths for small arities in caml_js_fun_call (and others)

[alainfrisch]

In the same way as caml_js_new, one could add fast paths in caml_js_fun_call and other similar functions to avoid copying the array of arguments:

function caml_js_fun_call(f, args) {
  switch (args.length) {
  case 1: return f.call(null);
  case 2: return f.call(null, args[1]);
  case 3: return f.call(null, args[1], args[2]);
  case 4: return f.call(null, args[1], args[2], args[3]);
  // ad libitum
  }
  return f.apply(null, caml_js_from_array(args));
}

The compiler could also detect cases where caml_js_fun_call is called on an array of known size to inline the corresponding branch directly. Or, alternatively, one could expose specialized primitives caml_js_fun_call1, caml_js_fun_call2.

The micro-benchmark below runs about 15x faster with the version of caml_js_fun_call above.

let () =
  let r = ref [| Js.Unsafe.inject 1 |] in
  for i = 1 to 10000000 do
    if i < 1 then r := [| Js.Unsafe.inject 0 |]; (* prevent wrong optim *)
   Js.Unsafe.fun_call (Js.Unsafe.variable "add") !r;
  done

    <script type="text/javascript">
      var accu = 0;
      function add(x) {  accu += x; }
      var t0 = new Date().getTime();
    </script>
    <script type="text/javascript" src="bench_js.js">
    </script>
    <script type="text/javascript">
      var t1 = new Date().getTime();
      alert("Sum = " + accu + "\nTime : " + (t1 - t0));
    </script>

[vouillon]

Do you have a use case for that?

The best case is when we can perform directly a JavaScript function call, without going through caml_js_fun_call. The compiler will perform this optimization when Js.Unsafe.fun_call is applied to a literal array. So, you don't need specialized primitives such as caml_js_fun_call2 as you can write instead:

let fun_call2 f x y = Js.Unsafe.fun_call f [|x; y|]

For caml_js_new, the issue is that we cannot have an arbitrary number of argument without changing the semantics (we have to use our own constructor).

[alainfrisch]

The use cases would be any case where caml_js_fun_call is actually
required. I've seen it in the following cases:

1. Calling the primitive through a non-inlined intermediate function:

   type t
   external variable: string -> t = "caml_js_var"
   external apply: t -> t array -> t = "caml_js_fun_call"
   let apply_unit f x = ignore (apply f x)
   let () =
    apply_unit (variable "foo1") [| |];
    apply_unit (variable "foo2") [| |];

   This generates:

   var _bj_=function(_a_,_b_){caml_js_fun_call_cc_(_a_,_b_);return 0};
   _bj_(foo1,[0]);
   _bj_(foo2,[0]);

2. When calling a variadic JS function (the array of arguments is really dynamic).