On Sat, 2004-05-29 at 02:47, Jacques Carette wrote:
> > It turns out that during output_value, the OCaml code allocates a
> > block of memory to contain the marshalled representation of the data.
> > Each time it runs out of room, it doubles the size of that block using
> > realloc().
> 
> Wouldn't it be more system-friendly to try successively factors *2, *1.5,
> *1.1, and *1.05 before actually failing? 

I have a published book chapter part of which deals with
this issue in some detail, including some performance
measurements.

The general solution is much cleaner -- to use
a user supplied allocation function something like:

new_size = f old_size requested_size

Doubling the size, or indeed even using a pure multiplier,
is only one possible option: simply adding a fixed amout
is another option, and an arbitrary function handles
both cases and many more. So a general solution is to make
the operation polymorphic by making the calculator function
an argument (in practice with a sensible default).

My experiments were with variable length arrays used
to hold big integers, so some operations produced
small increases (like addition) whereas other
produced increases much faster (like multiplication).

A quick and easy fix would be to use a global variable
containing the function which the client can reset.
Yeah, I hate global state but here the actual function
chosen has no semantic impact, it only affects performance
(unless you run out of memory .. of course). So this
time a global might be OK :)

-- 
John Skaller, mailto:skaller@users.sf.net
voice: 061-2-9660-0850, 
snail: PO BOX 401 Glebe NSW 2037 Australia
Checkout the Felix programming language http://felix.sf.net



-------------------
To unsubscribe, mail caml-list-request@inria.fr Archives: http://caml.inria.fr
Bug reports: http://caml.inria.fr/bin/caml-bugs FAQ: http://caml.inria.fr/FAQ/
Beginner's list: http://groups.yahoo.com/group/ocaml_beginners