Re: speed difference between Guile and Racket (and Python)

[Zelphir Kaltstahl]

Hi!

I think the only way to use multiple cores in Racket is to use "places" and that 
means starting new Racket VMs.

Lambdas are not easily serialized with all their environment, so it is difficult 
to actually "send a lambda" to another "place" (Racket VM) dynamically. The only 
way I found was to not send them at all, but predefine functions, so that they 
are already known in other places and do not need to be send. Instead send only 
data.

This makes it difficult to build a pool for things (threads, workers, etc.), 
that run on multiple cores and dynamically accept "work" to do. (– Has anyone 
done it? With dynamically calculated work being sent to the threads/workers? 
I've not seen an example.) This was unsatisfactory for me for implementing a 
decision tree algorithm, which is, why I originally took a look at Guile.

So I think as a consequence there is a lot of overhead when using multiple cores 
in Racket. At least initially, for starting Racket VMs (places).

(Correct me, if I am wrong about these things. It is only my experience from 
using Racket before using Guile, and I learned a lot since then.)

I would expect using futures on Guile to have much less overhead, than starting 
Racket places and fibers to have even less overhead than futures. But this is 
only guessing. From that I would expect multi-core with many separate tasks to 
run, to be faster on Guile. But again, merely guessing around. If sequential 
execution is faster in Racket, there is probably some point, at which 
parallelizing outweighs the benefits of sequentially being faster.

Regards,
Zelphir

On 11/7/22 10:21, Dr. Arne Babenhauserheide wrote:
> Damien Mattei <damien.mattei@gmail.com> writes:
>
> > when comparing the (almost) same code running on Guile and Racket i find
> > big speed difference:
> Schemes differ a lot in speed of different tasks, but Racket is one of
> the fastest ones. Factor 2 difference sounds plausible. For a
> comparison, see the r7rs benchmarks:
> https://ecraven.github.io/r7rs-benchmarks/
>
> That said, I have seen 10x speedups in Guile code when people went for
> optimizing it.
>
> > last version of code is here:
> > https://github.com/damien-mattei/library-FunctProg/blob/master/guile/logiki%2B.scm#L3092
> Could you give the shell commands to setup and run your speed-test?
>
> Best wishes,
> Arne

--
repositories: https://notabug.org/ZelphirKaltstahl