# Parallelism with Places

The `racket/place` library provides support for performance improvement
through parallelism with the `place` form. The `place` form creates a
_place_, which is effectively a new Racket instance that can run in
parallel to other places, including the initial place.  The full power
of the Racket language is available at each place, but places can
communicate only through message passing—using the `place-channel-put`
and `place-channel-get` functions on a limited set of values—which helps
ensure the safety and independence of parallel computations.

As a starting example, the racket program below uses a place to
determine whether any number in the list has a double that is also in
the list:

```racket
#lang racket                            
                                        
(provide main)                          
                                        
(define (any-double? l)                 
  (for/or ([i (in-list l)])             
    (for/or ([i2 (in-list l)])          
      (= i2 (* 2 i)))))                 
                                        
(define (main)                          
  (define p                             
    (place ch                           
      (define l (place-channel-get ch)) 
      (define l-double? (any-double? l))
      (place-channel-put ch l-double?)))
                                        
  (place-channel-put p (list 1 2 4 8))  
                                        
  (place-channel-get p))                
```

The identifier `ch` after `place` is bound to a _place channel_. The
remaining body expressions within the `place` form are evaluated in a
new place, and the body expressions use `ch` to communicate with the
place that spawned the new place.

In the body of the `place` form above, the new place receives a list of
numbers over `ch` and binds the list to `l`.  It then calls
`any-double?` on the list and binds the result to `l-double?`. The final
body expression sends the `l-double?` result back to the original place
over `ch`.

In DrRacket, after saving and running the above program, evaluate
`(main)` in the interactions window to create the new place. When using
places inside DrRacket, the module containg place code must be saved to
a file before it will execute.  Alternatively, save the program as
`"double.rkt"` and run from a command line with

  `racket -tm double.rkt`

where the `-t` flag tells `racket` to load the `double.rkt` module, the
`-m` flag calls the exported `main` function, and `-tm` combines the two
flags.

The `place` form has two subtle features. First, it lifts the `place`
body to an anonymous, module-level function.  This lifting means that
any binding referenced by the `place` body must be available in the
module’s top level. Second, the `place` form `dynamic-require`s the
enclosing module in a newly created place. As part of the
`dynamic-require`, the current module body is evaluated in the new
place.  The consequence of this second feature is that `place` should
not appear immediately in a module or in a function that is called in a
module’s top level; otherwise, invoking the module will invoke the same
module in a new place, and so on, triggering a cascade of place
creations that will soon exhaust memory.

```racket
#lang racket                                    
                                                
(provide main)                                  
                                                
; Don't do this!                                
(define p (place ch (place-channel-get ch)))    
                                                
(define (indirect-place-invocation)             
  (define p2 (place ch (place-channel-get ch))))
                                                
; Don't do this, either!                        
(indirect-place-invocation)                     
```