[Caml-list] is there a runtime cost for this

[Caml-list] is there a runtime cost for this

[Francois Berenger]

Hello,

In a .ml file I'd like to write something like this
in order to factorize some code:

let f x y z = [...] some code [...]

module Something = struct
     let g = f
end

module Something_else = struct
     let h = f
end

Is calling Something.g or Something_else.h as efficient
as calling f directly?

-- 
Best regards,
Francois Berenger.

Re: [Caml-list] is there a runtime cost for this

[Goswin von Brederlow]

On Tue, Feb 04, 2014 at 10:41:50AM +0900, Francois Berenger wrote:
> Hello,
> 
> In a .ml file I'd like to write something like this
> in order to factorize some code:
> 
> let f x y z = [...] some code [...]
> 
> module Something = struct
>     let g = f
> end
> 
> module Something_else = struct
>     let h = f
> end
> 
> Is calling Something.g or Something_else.h as efficient
> as calling f directly?

I would expect this to result in identical code. But you know, you
could just compile both versions, objdump -d and compare the two
results.

MfG
	Goswin

Re: [Caml-list] is there a runtime cost for this

[Gerd Stolpmann]

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

Am Dienstag, den 04.02.2014, 10:41 +0900 schrieb Francois Berenger:
> Hello,
> 
> In a .ml file I'd like to write something like this
> in order to factorize some code:
> 
> let f x y z = [...] some code [...]
> 
> module Something = struct
>      let g = f
> end
> 
> module Something_else = struct
>      let h = f
> end
> 
> Is calling Something.g or Something_else.h as efficient
> as calling f directly?

This is the same: For the calls of g and h ocamlopt generates code that
actually calls f. Even the eta-expanded version is cheap:

module Something = struct
     let g2 x y z = f x y z
end

The code for g2 consists just of a jump to the body of f. (And normally
the inlining feature of ocamlopt even changes calls to g into calls to
f.)

Generally, ocamlopt is very good at function calls, no matter which
variant (direct or indirect call, with or without curried arguments,
inside an inner module or a functor). Don't put too much effort into
optimizing this by hand.

Gerd

> 
> -- 
> Best regards,
> Francois Berenger.
> 

-- 
------------------------------------------------------------
Gerd Stolpmann, Darmstadt, Germany    gerd@gerd-stolpmann.de
My OCaml site:          http://www.camlcity.org
Contact details:        http://www.camlcity.org/contact.html
Company homepage:       http://www.gerd-stolpmann.de
------------------------------------------------------------


[-- Attachment #2: This is a digitally signed message part --]
[-- Type: application/pgp-signature, Size: 490 bytes --]

Re: [Caml-list] is there a runtime cost for this

[rixed]

As long as Something and Something_else are not functors, you
can even compile f separately from these two modules and still
your code calling Something.g should actually call f instead.

If there are some functors, that's another story, unfortunately.