Point to new Turing docs page

Author: penelopeysm

HISTORY.md

@@ -17,18 +17,20 @@ If you were previously relying on this behaviour, you will need to store a VarIn
 
 #### Threadsafe evaluation
 
-DynamicPPL models are by default no longer thread-safe.
-If you have threading in a model, you **must** now manually mark it as so, using:
+DynamicPPL models have traditionally supported running some probabilistic statements (e.g. tilde-statements, or `@addlogprob!`) in parallel.
+Prior to DynamicPPL 0.39, thread safety for such models used to be enabled by default if Julia was launched with more than one thread.
+
+In DynamicPPL 0.39, **thread-safe evaluation is now disabled by default**.
+If you need it (see below for more discussion of when you _do_ need it), you **must** now manually mark it as so, using:
 
 ```julia
 @model f() = ...
 model = f()
 model = setthreadsafe(model, true)
 ```
 
-It used to be that DynamicPPL would 'automatically' enable thread-safe evaluation if Julia was launched with more than one thread (i.e., by checking `Threads.nthreads() > 1`).
-
-The problem with this approach is that it sacrifices a huge amount of performance.
+The problem with the previous on-by-default is that it can sacrifice a huge amount of performance when thread safety is not needed.
+This is especially true when running Julia in a notebook, where multiple threads are often enabled by default.
 Furthermore, it is not actually the correct approach: just because Julia has multiple threads does not mean that a particular model actually requires threadsafe evaluation.
 
 **A model requires threadsafe evaluation if, and only if, the VarInfo object used inside the model is manipulated in parallel.**
@@ -41,9 +43,11 @@ This can occur if any of the following are inside `Threads.@threads` or other co
 If you have none of these inside threaded blocks, then you do not need to mark your model as threadsafe.
 **Notably, the following do not require threadsafe evaluation:**
 
-  - Using threading for anything that does not involve VarInfo. For example, you can calculate a log-probability in parallel, and then add it using `@addlogprob!` outside of the threaded block. This does not require threadsafe evaluation.
+  - Using threading for any computation that does not involve VarInfo. For example, you can calculate a log-probability in parallel, and then add it using `@addlogprob!` outside of the threaded block. This does not require threadsafe evaluation.
   - Sampling with `AbstractMCMC.MCMCThreads()`.
 
+For more information about threadsafe evaluation, please see [the Turing docs](https://turinglang.org/docs/usage/threadsafe-evaluation/).
+
 #### Parent and leaf contexts
 
 The `DynamicPPL.NodeTrait` function has been removed.

docs/src/api.md

@@ -42,7 +42,7 @@ The context of a model can be set using [`contextualize`](@ref):
 contextualize
 ```
 
-Some models require threadsafe evaluation (see https://turinglang.org/docs/THIS_DOESNT_EXIST_YET for more information on when this is necessary).
+Some models require threadsafe evaluation (see [the Turing docs](https://turinglang.org/docs/usage/threadsafe-evaluation/) for more information on when this is necessary).
 If this is the case, one must enable threadsafe evaluation for a model:
 
 ```@docs

src/compiler.jl

@@ -384,7 +384,7 @@ function generate_mainbody!(mod, found, expr::Expr, warn, warn_threads)
                 "It looks like you are using `Threads.@threads` in your model definition." *
                 "\n\nNote that since version 0.39 of DynamicPPL, threadsafe evaluation of models is disabled by default." *
                 " If you need it, you will need to explicitly enable it by creating the model, and then running `model = setthreadsafe(model, true)`." *
-                "\n\nAvoiding threadsafe evaluation can often lead to significant performance improvements. Please see https://turinglang.org/docs/THIS_PAGE_DOESNT_EXIST_YET for more details of when threadsafe evaluation is actually required."
+                "\n\nAvoiding threadsafe evaluation can often lead to significant performance improvements. Please see https://turinglang.org/docs/usage/threadsafe-evaluation/ for more details of when threadsafe evaluation is actually required."
             )
         end
         return generate_mainbody!(

src/model.jl

@@ -136,9 +136,9 @@ outside of the parallel region is safe without needing to set `threadsafe=true`.
 
 It is also not needed for multithreaded sampling with AbstractMCMC's `MCMCThreads()`.
 
-Setting `threadsafe` to `true` increases the overhead in evaluating the model. See
-(https://turinglang.org/docs/THIS_DOESNT_EXIST_YET)[https://turinglang.org/docs/THIS_DOESNT_EXIST_YET]
-for more details.
+Setting `threadsafe` to `true` increases the overhead in evaluating the model. Please see
+[the Turing.jl docs](https://turinglang.org/docs/usage/threadsafe-evaluation/) for more
+details.
 """
 function setthreadsafe(model::Model{F,A,D,M}, threadsafe::Bool) where {F,A,D,M}
     return if _requires_threadsafe(model) == threadsafe