Performance tips

This tutorial was generated using Literate.jl. Download the source as a .jl file.

By now you should have read the other "getting started" tutorials. You're almost ready to write your own models, but before you do so there are some important things to be aware of.

The Julia manual has an excellent section on Performance tips. The purpose of this tutorial is to highlight a number of performance issues that are specific to JuMP.

Required packages

This tutorial uses the following packages:

julia> using JuMP
julia> import HiGHS

Use macros to build expressions

Use JuMP's macros to build expressions.

Constructing an expression outside the macro results in intermediate copies of the expression. For example,

x[1] + x[2] + x[3]

is equivalent to

a = x[1]
b = a + x[2]
c = b + x[3]

Since we only care about c, the a and b expressions are not needed and constructing them slows the program down.

JuMP's macros rewrite the expressions to operate in-place and avoid these extra copies. Because they allocate less memory, they are faster, particularly for large expressions.

Here's an example.

julia> model = Model()A JuMP Model
├ solver: none
├ objective_sense: FEASIBILITY_SENSE
├ num_variables: 0
├ num_constraints: 0
└ Names registered in the model: none
julia> @variable(model, x[1:3])3-element Vector{VariableRef}:
 x[1]
 x[2]
 x[3]

Here's what happens if we construct the expression outside the macro:

julia> @allocated x[1] + x[2] + x[3]1296

If we use the @expression macro, we get many fewer allocations:

julia> @allocated @expression(model, x[1] + x[2] + x[3])736

Use add_to_expression! to build summations

If you don't want to use the expression macros, use add_to_expression! to build summations. For example, instead of:

julia> expr = zero(AffExpr)0
julia> for i in 1:3
           expr += x[i]
       end
julia> exprx[1] + x[2] + x[3]

do

julia> expr = zero(AffExpr)0
julia> for i in 1:3
           add_to_expression!(expr, x[i])
       end
julia> exprx[1] + x[2] + x[3]

The former is equivalent to:

julia> expr0 = zero(AffExpr)0
julia> expr1 = expr0 + x[1]x[1]
julia> expr2 = expr1 + x[2]x[1] + x[2]
julia> expr = expr2 + x[3]x[1] + x[2] + x[3]

which allocates four unique AffExpr objects. The latter efficiently updates expr in-place so that only one AffExpr object is allocated.

The function add_to_expression! also supports terms like y += a * x where a is a constant. For example, instead of:

julia> expr = zero(AffExpr)0
julia> for i in 1:3
           expr += i * x[i]
       end
julia> exprx[1] + 2 x[2] + 3 x[3]

do

julia> expr = zero(AffExpr)0
julia> for i in 1:3
           add_to_expression!(expr, i, x[i])
       end
julia> exprx[1] + 2 x[2] + 3 x[3]

Don't do this, because i * x[i] will allocate a new AffExpr in each iteration:

julia> expr = zero(AffExpr)0
julia> for i in 1:3
           add_to_expression!(expr, i * x[i])
       end
julia> exprx[1] + 2 x[2] + 3 x[3]

Disable string names

By default, JuMP creates String names for variables and constraints and passes these to the solver. The benefit of passing names is that it improves the readability of log messages from the solver (for example, "variable x has invalid bounds" instead of "variable v1203 has invalid bounds"), but for larger models the overhead of passing names can be non-trivial.

Disable the creation of String names by setting set_string_name = false in the @variable and @constraint macros, or by calling set_string_names_on_creation to disable all names for a particular model:

julia> model = Model();
julia> set_string_names_on_creation(model, false)
julia> @variable(model, x)_[1]
julia> @constraint(model, c, 2x <= 1)2 _[1] ≤ 1

Note that this doesn't change how symbolic names and bindings are stored:

julia> x_[1]
julia> model[:x]_[1]
julia> x === model[:x]true

But you can no longer look up the variable by the string name:

julia> variable_by_name(model, "x") === nothingtrue

Sparsity

JuMP executes the code that you write without trying to be clever about multiplication by 0.0. For example, consider this model:

julia> d = 100_000100000
julia> a = zeros(d);
julia> a[3] = 1.01.0
julia> model = Model();
julia> @variable(model, x[1:d]);
julia> complicated_expression(x, i) = x[i]^2complicated_expression (generic function with 1 method)
julia> @expression(model, sum(a[i] * complicated_expression(x, i) for i in 1:d))x[3]²

Although the final expression consists of a single element, the sum is over 100,000 elements, all but one of which are then multiplied by 0.0. The @expression line is equivalent to:

julia> expr = zero(QuadExpr)0
julia> for i in 1:d
           tmp = complicated_expression(x, i)
           global expr = add_to_expression!(expr, a[i], tmp)
       end

Notice how we compute complicated_expression in every iteration, even though most results will be discarded. You can improve the performance of model construction by pre-computing the set of non-zero indices:

julia> indices = [i for i in 1:d if !iszero(a[i])]1-element Vector{Int64}:
 3
julia> @expression(model, sum(a[i] * complicated_expression(x, i) for i in indices))x[3]²