[Haskell-cafe] Something like optimistic evaluation

[Brent Yorgey]

On Mon, Apr 28, 2008 at 6:09 PM, Daniil Elovkov <
daniil.elovkov at googlemail.com> wrote:

> Hello
>
> Somewhat on the topic of optimistic evaluation, I've just thought of
> another way to evaluate thunks.
>
> When the program is about to block on some IO, what if we start a thread to
> evaluate (any) unevaluated thunks. We'll have additional system thread, but
> the blocked one will not actually consume any processor time.
>
> This would take place only when the program is compiled as threaded and run
> with -N k, k>1.
>
> The RTS knows at least about some operations that will block, those which
> IO operations are implemented with. for example. It could merely start a
> process of evaluating any (or something more clever) outstanding thunks
> right before going into one of those operations and stop it when it's back.
>
> Of course, it's not like optimistic evaluation because we don't avoid
> creating thunks. But in a sense it's similar. It could also be compared with
> incremental garbage collection :)
>
> Has something like that been done, discussed?
>

This sounds like it could be helpful in certain circumstances, but in many
cases it could probably lead to unpredictable (and uncontrollable!) memory
usage.  I could imagine a situation where my program is running along just
fine, and then one day it takes a long time to do a read from the network
due to latency or whatever, and suddenly memory usage shoots through the
roof, due to evaluation of some infinite (or even just very large) data
structure.

-Brent
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.haskell.org/pipermail/haskell-cafe/attachments/20080429/a6a7371f/attachment.htm