2009-12-07

We're pleased to announce the initial release of parallel futures, a
construct for fine-grained parallelism in PLT. Roughly speaking, a
programmer passes a thunk to 'future' and it gets run in parallel.
That "roughly" holds a few gotchas, partly because we're just getting
started and partly due to the technique we're using. See the
documentation for more details:

Note that you have to build mzscheme with futures; it isn't enabled by
default, but see the docs above for how to do that. Beyond the above,
we've also gotten a few parallel kernels going and are seeing good
scalability up to 8 cores (the biggest machine we have around for the
time being).

No. You can have as many versions as you want, completely separate. (Double clicking in the finder will always choose one of the open drschemes; I haven't figured out what the OS does when none of them are open.)

It seems to me that delay/thread in scheme/promise has an analogous existing interface to a later forced-touched promise-future. Outside the very important and appreciated implementation difference of having multiple CPUs, where does the analogy fall short enough to require a different set of functions?

Well, parallelism is an important difference, of course (enough that warrants its own, separate api so programmers know what they are getting), but another difference is that with promises the computation won't get "frozen" in the way that futures can get frozen.