[Caml-list] Overhead of first class modules

[Caml-list] Overhead of first class modules

[Alex Rubinsteyn]

[-- Attachment #1: Type: text/plain, Size: 972 bytes --]

I ran a very simple experiment gauging the overhead of OCaml's new
first-class modules.

*direct.ml: *
let f x = x + 1
let _ =
  let acc = ref 0 in
  for i = 0 to 10000000 do
    acc := !acc + (f 1)
  done

*first_class_module.ml*
module type S = sig val f : int -> int end
module M = struct let f x = x + 1 end
let package = (module M : S)
let _ =
  let acc = ref 0 in
  for i = 0 to 10000000 do
     let module Local = (val package : S) in
     acc := !acc + (Local.f 1)
  done

obj.ml
let o = object method f x = x + 1 end
let _ =
  let acc = ref 0 in
  for i = 0 to 10000000 do
     acc := !acc + o#f 1
  done


# ocamlopt direct.ml -o direct
# ocamlopt first_class_module.ml -o first_class_module
# ocamlopt obj.ml -o obj

# time ./direct
real 0m0.008s
user 0m0.010s

# time ./first_class_module
real 0m0.012s
user 0m0.020s

# time ./obj
real 0m0.058s
user 0m0.060s

So, the overhead of first class modules is slight, especially when compared
with method invocation.

[-- Attachment #2: Type: text/html, Size: 2436 bytes --]

Re: [Caml-list] Overhead of first class modules

[ygrek]

On Fri, 16 Sep 2011 16:08:55 -0400
Alex Rubinsteyn <alex.rubinsteyn@gmail.com> wrote:

> I ran a very simple experiment gauging the overhead of OCaml's new
> first-class modules.

This is not a valid experiment. In first two cases ocamlopt inlines
function call. Also mind that in this code ocamlopt calls the 
Local.f function directly, not through the module.

But let's correctly microbenchmark the cost of direct call vs
indirect vs message sending :)

let n = 100_000_000

let f x = x + 1
let direct () =
  let acc = ref 0 in
  for i = 0 to n do
    acc := !acc + (f 1)
  done

module type S = sig val f : int -> int end
module M = struct let f x = x + 1 end
let package = ref (module M : S)
let fstcls () =
  let acc = ref 0 in
  for i = 0 to n do
     let module Local = (val !package : S) in
     acc := !acc + (Local.f 1)
  done

let o = object method f x = x + 1 end
let obj () =
  let acc = ref 0 in
  for i = 0 to n do
     acc := !acc + o#f 1
  done

let () = 
  match Sys.argv with
  | [|_;"direct"|] -> direct ()
  | [|_;"fstcls"|] -> fstcls ()
  | [|_;"obj"|] -> obj ();
  | _ -> failwith "ORLY?"

Disable inlining :

 /opt/ocaml-3.12.1/bin/ocamlopt -inline 0 -S speed.ml -o speed

Run (Linux 3.0.0-1-686-pae i686) :

$ time ./speed direct

real	0m0.711s
user	0m0.560s
sys	0m0.012s

$ time ./speed fstcls

real	0m0.631s
user	0m0.508s
sys	0m0.000s

$ time ./speed obj

real	0m1.157s
user	0m0.840s
sys	0m0.016s

Looks like it is time to sprinkle some performance-critical code with first class modules :)

-- 
 ygrek
 http://ygrek.org.ua