Re: [Caml-list] Array Optimizations

["Rolf Wester" <rolf.wester@ilt.fhg.de>]

> Hi all,
> 
> The following paper (that I found by chance)
> http://www.cs.cornell.edu/Courses/cs612/2001SP/projects/ocaml-arrays/OCaml.pdf
> describes a set of optimizations that improves array access speed in
> Caml _without_loosing_bound_checking_ (contrarily to the -unsafe
> option).  The performance gain on their examples looks good, in fact
> they even beat gcc in some cases!  In their words:
> 
>  The final performance of MMM surpasses even that of the
>  best-case baseline kernel --- the linearized 1D Array with
>  bounds checking disabled --- yet without sacrificing the
>  safety of bounds checking or requiring the programmer to
>  linearize accesses.
> 
> and
> 
>  We conclude that OCaml could be a serious contender against
>  languages such as C and Fortran for use in numerically
>  intensive computation.
> 
> Is there anything like that (to be) implemented into the OCaml
> compilers?  I believe many people besides myself will be interested to
> have the power of Caml available with extremely good array access
> times in loops.
> 
> Keep up with the good work!
> 
> Cheers,
> ChriS
> 
> 
> P.S.  As outlined in the paper, the Bigarray library is really slow
> (much slower than the standard Array).  Given its (other)
> capabilities, it is tempting to use it for numeric processing however.
> Until this is solved, shouldn't there be a warning somewhere (in the
> manual?).
> 
I my experience with Array and Bigarray the difference isn't so significant
as it is in the above mentioned paper. Nevertheless I would very much 
appreciate Array and Bigarray perfomance comparable to C/C++. In that
case may be I could convince some of my colleagues to use OCaml for
their numerical work. Another approach could be to write a module comparable
to the Python Numpy package. In any case complex numbers in Bigarray
would be fine. 

Rolf Wester

P.S.: At the moment I write a wrapper for interfacing with a subset of FFTW.
I use Bigarray float64 as a complex array with re(i) = v.{2*i} and im(i)=v.{2*i+1}.
Does anybody have a better idea? 

-------------------------------------
Rolf Wester
rolf.wester@ilt.fraunhofer.de
-------------------
Bug reports: http://caml.inria.fr/bin/caml-bugs  FAQ: http://caml.inria.fr/FAQ/
To unsubscribe, mail caml-list-request@inria.fr  Archives: http://caml.inria.fr