Use multithreading

SDDP.jl can take advantage of the parallel nature of modern computers to solve problems across multiple threads.

Enabling threads

By default, starting Julia with julia enables only a single thread. To enable more threads, you must start Julia from a command line using the --threads flag, where N is the number of threads to use:

julia --threads N

Alternatively, you may set the JULIA_NUM_THREADS environment variable to N before starting Julia. (There is no way to change the number of threads once Julia has started.)

Once Julia has started, check how many threads you have available using Threads.nthreads(). For this online documentation, we set the JULIA_NUM_THREADS environment variable to 4 before starting Julia:

julia> ENV["JULIA_NUM_THREADS"]
"4"

julia> Threads.nthreads()
4

Multithreading with SDDP

To enable the multithreading algorithm in SDDP.jl, pass an instance of SDDP.Threaded to the parallel_scheme argument of SDDP.train and SDDP.simulate.

julia> using SDDP, HiGHS
julia> model = SDDP.LinearPolicyGraph(
           stages = 12,
           lower_bound = 0,
           optimizer = HiGHS.Optimizer,
       ) do sp, t
           @variable(sp, x >= 0, SDDP.State, initial_value = 1)
           @stageobjective(sp, x.out)
       endA policy graph with 12 nodes.
 Node indices: 1, ..., 12
julia> SDDP.train(
           model;
           iteration_limit = 10,
           log_every_iteration = true,
           parallel_scheme = SDDP.Threaded(),
       )-------------------------------------------------------------------
         SDDP.jl (c) Oscar Dowson and contributors, 2017-25
-------------------------------------------------------------------
problem
  nodes           : 12
  state variables : 1
  scenarios       : 1.00000e+00
  existing cuts   : false
options
  solver          : Threaded()
  risk measure    : SDDP.Expectation()
  sampling scheme : SDDP.InSampleMonteCarlo
subproblem structure
  VariableRef                             : [3, 3]
  VariableRef in MOI.GreaterThan{Float64} : [2, 2]
  VariableRef in MOI.LessThan{Float64}    : [1, 1]
numerical stability report
  matrix range     [0e+00, 0e+00]
  objective range  [1e+00, 1e+00]
  bounds range     [0e+00, 0e+00]
  rhs range        [0e+00, 0e+00]
-------------------------------------------------------------------
 iteration    simulation      bound        time (s)     solves  pid
-------------------------------------------------------------------
         1   0.000000e+00  0.000000e+00  1.261001e-01        54   1
         2   0.000000e+00  0.000000e+00  1.309180e-01        89   4
         3   0.000000e+00  0.000000e+00  1.322820e-01       112   3
         4   0.000000e+00  0.000000e+00  1.334641e-01       138   4
         5   0.000000e+00  0.000000e+00  1.337142e-01       143   2
         6   0.000000e+00  0.000000e+00  1.342881e-01       171   2
         7   0.000000e+00  0.000000e+00  1.358821e-01       204   4
         8   0.000000e+00  0.000000e+00  1.373460e-01       245   4
        10   0.000000e+00  0.000000e+00  1.385961e-01       264   3
        11   0.000000e+00  0.000000e+00  1.387751e-01       266   3
        12   0.000000e+00  0.000000e+00  1.407762e-01       310   4
        13   0.000000e+00  0.000000e+00  1.410251e-01       312   2
-------------------------------------------------------------------
status         : iteration_limit
total time (s) : 1.410251e-01
total solves   : 312
best bound     :  0.000000e+00
simulation ci  :  0.000000e+00 ± 0.000000e+00
numeric issues : 0
-------------------------------------------------------------------
julia> simulations = SDDP.simulate(
           model,
           100;
           parallel_scheme = SDDP.Threaded(),
           custom_recorders =
               Dict{Symbol,Function}(:thread_id => sp -> Threads.threadid()),
       );
julia> simulations[1][1][:thread_id]1
julia> simulations[26][1][:thread_id]2
julia> simulations[51][1][:thread_id]4
julia> simulations[76][1][:thread_id]3

Choosing the number of threads

As a rule of thumb, choose the number of threads to be less than or equal to the number of physical cores you have on your machine or the number of nodes in the graph, whichever is smaller.

The performance of the multithreaded algorithm in SDDP.jl is strongly limited by the number of nodes in your policy graph; more nodes is better. The number of threads that can be used is upper bounded by the number of nodes in the graph. For example, if you have a graph with three nodes, SDDP.jl will never use more than three threads, even if --threads 4 is passed.

Even if you have a large number of nodes, using more threads than you have physical cores is likely to lead to bad performance. For example, on a quad-core laptop, using --threads 52, is likely to lead to bad performance, even if you have a graph with 52 nodes.