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

(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)

(define/contract (parallel-set-map proc st send-print-pch)
  (-> (and/c serializable? (-> any/c any/c))
      (set/c any/c)
  (define-values {manager-pch worker-pch}
  (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)
  (define results
    (let loop ([so-far (set)]
               [i 1])
      (define st
        (set-add so-far (sync manager-pch)))
      (if (= i count)
          (loop st (add1 i)))))
  (for-each place-kill workers)

(define (try-it)
  (define example-set
    (set 1 2 3))
  (define-values {get-print-pch send-print-pch}
  (thread (λ ()
            (let loop ()
              (write-string (sync get-print-pch) (current-output-port))
  (place-printf send-print-pch
                (parallel-set-map (serial-lambda (x)
                                    (+ x x))
  (place-printf send-print-pch
                (parallel-set-map (serial-lambda (x)
                                    (* x x))


On Sun, Apr 15, 2018 at 3:08 PM, Philip McGrath <phi...@philipmcgrath.com>

> On Sun, Apr 15, 2018 at 2:51 PM, Zelphir Kaltstahl <
> 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.

Reply via email to