Dear list readers,

to me it seems this benches only the object creation, not the method dispatch.

So the main result here is that object creation is quite expensive, and record field selection is 2 times faster than getting a value by a method.

Just change foo_s to a constant class instance removing the _ parameter.

Max

Dear OCaml users,

consider the following microbenchmark:

<snip>

class s (z : string)  (y : int)  (x : int) =
  object method z = z method y = y method x = x
end

type t = { x : int; y : int; z : string}

let foo_s _ =
 (new s) "Example" 0 1

let foo_t _ = {x=1; y=0; z="Example"}

let one_s _ = (foo_s ())#x

let one_t _ = (foo_t ()).x

let fac =
  let rec fac n =
    let f =
      let rec f n a = if n <= 1 then a else f (n - (one_s ())) (n * a)  in f (* change one_t to one_s or vice-versa *)
       in
    f n 1  in
  fac
let bench =
  let rec bench n a =
    if n <= 0
    then a
    else (let x = a && ((fac 20) == (20 * (fac 19)))  in bench (n - 1) x)  in
  bench
let test = bench 10000000 true
let main _ = test

</snip>

If I run it with ocamlopt 4.05.0+flambda and -O3, the version that uses one_s takes about 7.5s whereas the one with one_t uses 0.35s. I know that object method lookup is more costly than records, of course. This particular case baffles me, though. Why is the class not completely inlined?

Also as a related question, is there a way to have the lookup semantics of methods without the open recursion part? That is, can I have a class that consists of values, not methods? It would love to have open tuples in some cases. For example, I'd like to write a function that takes a tuple of any length, because it only needs the first element.

thanks,

Christoph