[Caml-list] Lazy vs closure

["Vladimir N. Silyaev" <vsilyaev@mindspring.com>]

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

After reading list and seeing statement that lazy/Lazy.force is faster then
closure/apply, I've decided to run microbenchmark with both.
Results are rather confusing:
 Byte code - Lazy is three times slower than closure
 Native code (x86) - it's either coredumps or leaks memory

Code attached as <<lazy.ml>>. With it's current form native code
leaks memory, by uncommenting first two lines it would coredump.

Also both compilers tends to generate rather strange error.
=-=-=-=-=-=
The files lazy.cmi and lazy.cmi make inconsistent assumptions
over interface Lazy
=-=-=-=-=-=
This error fixable by removing lazy.cmi from a disk.

Have I stepped on some known bug/feature?

Vladimir



[-- Attachment #2: lazy.ml --]
[-- Type: text/plain, Size: 490 bytes --]

(* Uncomment me
let l = lazy (1+1)

let _ = Lazy.force l
*)

let fixit = ref 0


let test_lazy n = 
  let l = lazy (n+1) in
   fixit := Lazy.force l

let test_closure n = 
  let c  = (fun _ -> n+1) in
    fixit := c ()

let test n test = 
  let start = Sys.time () in
    for i=0 to n do
       test i
    done;
    (Sys.time ()) -. start

let result = 
  List.map (test 1000000) [test_lazy; test_closure]


let _ = List.iter print_endline (List.map string_of_float result)