Re: [Caml-list] Local functions with arguments or closures ?

["Alain Coste" <alaincoste@club-internet.fr>]

Hello,

This question recalls me a related one I am often asking myself  when 
writing large functions (say 50 to 100 lines) which use several auxilliary 
functions sharing the same parameters. For example

let f x =
    let g1 () = .. reference to x ... in
    .......
    let gn () = .... reference to x .... in
    calls to to g1() ... gn()

I would like to have an idea of the cost of putting the code of g1...gn 
"inside" f  rather than defining them separately and passing x as a 
parameter, or using a reference

With x as parameter:

let g1 x = .....
....
let gn x = ....
let f x = calls to g1 x .... gn x

Or with a reference:

let f =
    let xr = ref 0 in
    let g1 () = ...!xr ... in
    ....
    let gn () = ... !xr... in
    fun x -> xr := x; .. calls to g1()...gn()

Some years ago I had the same problem with an interpreted language, and the 
answer was clearly in favor of the second or third solution, as the body of 
the function f was evaluated only when the function was applied (and as many 
times it was applied).
But it seems that with a compiler things are different as the body of the 
large function is treated at compile time, and only once. So I suppose the 
extra cost is only to build a closure, but does not depend on the size of 
the body of the large function f.
I generally use the first solution, but I sometimes have some doubts 
concerning efficiency...

Alain Coste

----- Original Message ----- 
From: "Gerd Stolpmann" <info@gerd-stolpmann.de>
To: "Gabriel Scherer" <gabriel.scherer@gmail.com>
Cc: "Daniel Bünzli" <daniel.buenzli@erratique.ch>; "caml-list" 
<caml-list@inria.fr>
Sent: Thursday, June 07, 2012 10:09 PM
Subject: AW: [Caml-list] Local functions with arguments or closures ?


I think it depends very much would you do inside your loop. In
Gabriel's example, there is only an addition, so you will probably see
a difference in runtime. But that's not what you do in practice here.
Imagine the loop iterates over a data structure, and let's assume it is
big enough that it is not completely cached. Then, the few extra
register loads will make no difference, they are just hidden by the
speculative execution done by modern CPUs (i.e. the loads are done
while the CPU waits for the data from RAM).

So yes, passing the arguments explicitly is probably only worth for
extremely simple cases that do not access data massively, but otherwise
use the style you like.

Gerd