On 12/12/2010 08:09 PM, Benedikt Meurer wrote:
> The boxing involved is relevant, but boxing in general is not the
> issue. In this special case, the "let nlen, n = if..." code requires
> heap allocation, because of the way the pattern is compiled. This could
> be fixed by moving the condition out of the code and using two if's to
> select n/nlen separately (doesn't speed up that much). Fixing the
> pattern compiler to handle these cases might be interesting for general
> benefit.

Instead of duplicating the conditional, you could also push the 
assignments to bound variables down the expression. For instance:

let (x, y) = if b then (u, v) else (v, u) in ...

can be replaced, conceptually, by:

let x = <dummy> in
let y = <dummy> in
if b then (x <- u; y <- v) else (x <- v; y <- u);
...

and similarly when the bound expression is a pattern matching.


I've played with this a few months ago and could observe important 
speedups (27%, 20%) on two micro-benchmarks.

The diff is really small:

http://caml.inria.fr/cgi-bin/viewcvs.cgi/ocaml/branches/inplace_let/bytecomp/matching.ml?rev=10475&sortby=date&r2=10475&r1=10474


-- Alain



Micro benchmark 1:

let () =
   for k = 1 to 10000 do
     for i = 1 to 100000 do
       let (x, y) =
         if i mod 2 = 0 then (1, i * 2)
         else (2, i * 3)
       in
       r := !r * x + y
     done
   done



Micro benchmark 2:

let f x y z =
   let a, b =
     match z with
     | Some (u, v) -> u, v * 2
     | None -> 10, 20
   in
   a * x + b * y

let () =
   let r = ref 0 in
   for k = 1 to 2000 do
     for i = 1 to 100000 do
       r := !r + f k i (Some (k, i));
       r := !r + f k i None
     done
   done