bigarrays much lower than normal ones

[Hal Daume III <hdaume@ISI.EDU>]

I've been hitting the limiting size of normal float arrays and was having 
a look at the Bigarray module.  Unfortunately, it seems roughly 3-4 times 
*slower* than the standard array, which is pretty much unacceptable for 
me.  Am I doing something naively wrong, or are the Bigarrays truly this 
slow?  The timing results I get (i686, redhat) are along the liens of:

stdarray, safe:

  12.000u 0.030s 0:12.18 98.7%    0+0k 0+0io 107pf+0w
  12.060u 0.030s 0:12.22 98.9%    0+0k 0+0io 107pf+0w

stdarray, unsafe:

  11.990u 0.070s 0:12.21 98.7%    0+0k 0+0io 107pf+0w
  12.130u 0.040s 0:12.31 98.8%    0+0k 0+0io 107pf+0w

bigarray, 64 bit:

  39.760u 0.040s 0:40.35 98.6%    0+0k 0+0io 110pf+0w
  39.750u 0.030s 0:40.09 99.2%    0+0k 0+0io 110pf+0w

bigarray, 32 bit:

  41.950u 0.050s 0:42.60 98.5%    0+0k 0+0io 110pf+0w
  42.070u 0.040s 0:42.53 99.0%    0+0k 0+0io 110pf+0w


(safe vs. unsafe is when compiled normally or with -unsafe; 64bit vs 32bit 
is the 'kind' used for the bigarrays.)

I'm also really shocked that the 32 bit float bigarrays are slower than 
the 64 bit ones!

Can someone explain this to me?

The code is:

<standard array>

open Array

let normalize a = 
  let s = fold_left (+.) 0. a in
    for i = 0 to length a - 1 do
      a.(i) <- a.(i) /. s;
    done;
    ()

let _ =
  let a = make 1000000 0. in
    for iter = 1 to 100 do
      for i = 0 to 999999 do
        let i' = float_of_int i in
          a.(i) <- log (0.01 *. i' *. i' +. 3. *. i' +. 4.);
      done;
      normalize a;
    done;
    ()



<big array>

open Bigarray

let normalize a =
  let _N = Array1.dim a in
  let rec sum n acc =
    if n >= _N then acc
    else sum (n+1) (acc +. Array1.get a n) in
  let s = sum 0 0. in
    for i = 0 to _N - 1 do
      Array1.set a i (Array1.get a i /. s);
    done;
    ()

let _ =
  let a = Array1.create float32 c_layout 1000000 in
    for iter = 1 to 100 do
      for i = 0 to 999999 do
        let i' = float_of_int i in
          Array1.set a i (log (0.01 *. i' *. i' +. 3. *. i' +. 4.));
      done;
      normalize a;
    done;
    ()





If you put the array allocation inside the iter loop, nothing changes 
much, relatively, on the timing results.

 - Hal


-- 
 Hal Daume III                                   | hdaume@isi.edu
 "Arrest this man, he talks in maths."           | www.isi.edu/~hdaume