Thanks for the example code.
I will look at it soon, when I can code on that code again and see where
I can get. Seems I misunderstood and thought you were suggesting to use
the non-ergonomic way of identifying procedures for serial-lambda.
That's probably, because I do not understand the source code of the
serial-lambda macro, which I looked at for a moment.
So maybe serial-lambda will save me in the end : ) Will try soon and
thank you! (I think I should also reorganize the code in the repo,
because all the comments make it hard to grasp a lot of the code at one
look. Maybe need to split things up and write comments or explanations
at the top in a lot of detail and references to the code and then just
let the code be there.)
On 15.04.2018 22:47, Philip McGrath wrote:
> If an example would be helpful, here's a toy implementation of
> `parallel-set-map` that uses `serial-lambda` to send the user-supplied
> function across the place-channels:
>
> #lang racket
>
> (require web-server/lang/serial-lambda
> racket/serialize
> )
>
> (define (place-printf pch fmt . args)
> (place-channel-put pch (apply format fmt args)))
>
> (define (spawn-worker id pch print-pch srl-proc)
> (place/context _
> (define proc
> (deserialize srl-proc))
> (let loop ()
> (let* ([v (sync pch)]
> [rslt (proc v)])
> (place-printf print-pch "place ~a:\t~a -> ~a\n" id v rslt)
> (place-channel-put pch rslt)
> (loop)))))
>
> (define/contract (parallel-set-map proc st send-print-pch)
> (-> (and/c serializable? (-> any/c any/c))
> (set/c any/c)
> place-channel?
> any/c)
> (define-values {manager-pch worker-pch}
> (place-channel))
> (define workers
> (for/list ([id (in-range 2)])
> (spawn-worker id worker-pch send-print-pch (serialize proc))))
> (define count
> (for/sum ([v (in-set st)])
> (place-channel-put manager-pch v)
> 1))
> (define results
> (let loop ([so-far (set)]
> [i 1])
> (define st
> (set-add so-far (sync manager-pch)))
> (if (= i count)
> st
> (loop st (add1 i)))))
> (for-each place-kill workers)
> results)
>
> (define (try-it)
> (define example-set
> (set 1 2 3))
> (define-values {get-print-pch send-print-pch}
> (place-channel))
> (thread (λ ()
> (let loop ()
> (write-string (sync get-print-pch) (current-output-port))
> (loop))))
> (place-printf send-print-pch
> "~v\n"
> (parallel-set-map (serial-lambda (x)
> (+ x x))
> example-set
> send-print-pch))
> (place-printf send-print-pch
> "~v\n"
> (parallel-set-map (serial-lambda (x)
> (* x x))
> example-set
> send-print-pch)))
>
>
> -Philip
>
> On Sun, Apr 15, 2018 at 3:08 PM, Philip McGrath
> <phi...@philipmcgrath.com <mailto:phi...@philipmcgrath.com>> wrote:
>
> On Sun, Apr 15, 2018 at 2:51 PM, Zelphir Kaltstahl
> <zelphirkaltst...@gmail.com <mailto:zelphirkaltst...@gmail.com>>
> wrote:
>
> Having to write all things in terms of where things come from
> like in:
>
> > '([racket/base +] . [1 2])
>
> is not ergonomic at all.
>
>
> Absolutely! To be clear, I was not suggesting that you use that
> format in practice: I was trying to illustrate part of the
> low-level mechanism by which `serial-lambda` (and
> `racket/serialize` in general) work.
>
> Using `serial-lambda` does all of the difficult accounting for you
> to make sure the right function from the right module is there
> when you deserialize it and to arrange for the serializable
> procedure to take its lexical environment along with it. You do
> have to be sure that you're dealing with pure functions and
> serializable data structures, but you can use it as a drop-in
> replacement for `lambda` and get surprisingly far before you have
> to think about any of the details.
>
>
--
You received this message because you are subscribed to the Google Groups
"Racket Users" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to racket-users+unsubscr...@googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
