Memory consumption and time of @constraint

[Thuener]

I'm having some issues with memory consumption on JuMP. I have a problem that has too many constraints and the JuMP structures for macro @constraint is consuming too much memory.

Example:

using JuMP,CPLEX

function memuse()
 pid = getpid()
 return round(Int,parse(Int,readstring(`ps -p $pid -o rss=`))/1024)
end

memuse()
C = 300000
m = Model(solver=CplexSolver())
N = 100
@variable(m, x[1:N] >= 0)
@variable(m, Θ >= 0)

@objective(m, Max, Θ )
solve(m)

coef = rand(C,N)
m1= memuse()
tic()
@constraint(m, Θ .<= coef*x  )
time = toq()
gc()
m2 = memuse()
print("Memory consumption $(m2-m1) Mb and Time $(time)")

Memory consumption 1022 Mb and Time 11.076951813

Changing the @constraint to CPLEX.add_constrs.

m1= memuse()
tic()
rhs = zeros(C)
coef = hcat(-coef,ones(C));
CPLEX.add_constrs!(m.internalModel.inner, coef, '<', rhs)
time = toq()
gc()
m2 = memuse()

Memory consumption 447 Mb and Time 1.975631208

With JuMP this constraint consumes 2.28x more memory and become 5.6x more slower. Maybe JuMP should have some macro to add constraints direct to the model without storing any information about it.

[joehuchette]

In the first example, you're really seeing the cost of the vectorized syntax. Writing out the loop explicitly gives me about an order of magnitude speedup over the vectorized version:

for i in 1:size(coef,1)
    @constraint(m, Θ <= sum(coef[i,j]*x[j] for j in size(coef,2)))
end

I think the syntax for adding constraints directly to the model, bypassing JuMP, would look a lot like your second code example there :)

[mlubin]

Using vectorized syntax in JuMP is known to consume more memory (because of temporaries) and to be slower than scalar syntax.

[Thuener]

With:

@constraint(m,[i = 1:size(coef,1)], Θ <= sum(coef[i,j]*x[j] for j = 1:size(coef,2)))

Memory consumption 957 Mb and Time 18.123854547

I'm on a different computer, the results for CPLEX.add_constrs on this one are:
Memory consumption 377 Mb and Time 3.32205742

So the scalar syntax consumes 2.53x more memory and is 5.45x more slower then CPLEX.add_constrs. I don't see much difference between this values and the vectorized constraint. So the memory consumption of the vectorized constraint is almost the same as scalar syntax. I think the memory consumption is because of the auxiliary objects created by JuMP.

[mlubin]

Make sure you're timing this inside of a function. Performance at the global scope will be much worse.

[Thuener]

Ok. Using:

function addConstraints(m,x,coef)
 @constraint(m,[i = 1:size(coef,1)], Θ <= sum(coef[i,j]*x[j] for j = 1:size(coef,2)))
end

...

coef = rand(C,N)
m1= memuse()
tic()
addConstraints(m,x,coef)
time = toq()
gc()
m2 = memuse()
print("Memory consumption $(m2-m1) Mb and Time $(time)")

I got: Memory consumption 1180 Mb and Time 11.69368708

To be fair, I also tested the result of the vectorized constraint inside a function.

function addConstraints(m,x,coef)
 @constraint(m, Θ .<= coef*x  )
end

Memory consumption 1035 Mb and Time 14.692361745

[mlubin]

using JuMP,CPLEX

function memuse()
 pid = getpid()
 return round(Int,parse(Int,readstring(`ps -p $pid -o rss=`))/1024)
end

const C = 300000
const N = 100

function t1()
    m = Model(solver=CplexSolver())
    @variable(m, x[1:N] >= 0)
    @variable(m, Θ >= 0)

    @objective(m, Max, Θ )

    coef = rand(C,N)
    gc()
    m1= memuse()
    tic()
    @constraint(m, Θ .<= coef*x  )
    time = toq()
    gc()
    m2 = memuse()
    println("Memory consumption $(m2-m1) Mb and Time $(time)")
end

function t2()
    m = Model(solver=CplexSolver())
    @variable(m, x[1:N] >= 0)
    @variable(m, Θ >= 0)

    @objective(m, Max, Θ )

    coef = rand(C,N)
    gc()
    m1= memuse()
    tic()
    for i in 1:size(coef,1)
        @constraint(m, Θ <= sum(coef[i,j]*x[j] for j = 1:size(coef,2)))
    end
    time = toq()
    gc()
    m2 = memuse()
    println("Memory consumption $(m2-m1) Mb and Time $(time)")
end

println("t1")
t1()
t1()
println("t2")
t2()
t2()

gives

t1
Memory consumption 1359 Mb and Time 6.816507673
Memory consumption 1300 Mb and Time 6.256449671
t2
Memory consumption 649 Mb and Time 1.88936574
Memory consumption 693 Mb and Time 1.878137287

[Thuener]

The code above has some weird behavior. I prefer to create a function to add the constraints, because I'm worried about the overall memory use not the temporary created objects.

using JuMP,CPLEX

function memuse()
 pid = getpid()
 return round(Int,parse(Int,readstring(`ps -p $pid -o rss=`))/1024)
end

const C = 300000
const N = 100

function addconstraints(m,x,Θ,coef,p)
    if p == 1
      @constraint(m, Θ .<= coef*x  )
    elseif p == 2
      for i in 1:size(coef,1)
        @constraint(m, Θ <= sum(coef[i,j]*x[j] for j = 1:size(coef,2)))
      end
    elseif p ==3
      @constraint(m,[i = 1:size(coef,1)], Θ <= sum(coef[i,j]*x[j] for j = 1:size(coef,2)))
    else
      rhs = zeros(C)
      coef = hcat(-coef,ones(C));
      CPLEX.add_constrs!(m.internalModel.inner, coef, '<', rhs)
    
    end

end
function t(p)
    m = Model(solver=CplexSolver(CPX_PARAM_SCRIND=0))
    @variable(m, 0 <= x[1:N] <= 1)
    @variable(m, 0 <= Θ <= 1000)

    @objective(m, Max, Θ )
    solve(m)

    coef = rand(C,N)
    gc()
    m1= memuse()
    tic()
    addconstraints(m,x,Θ,coef,p)
    time = toq()
    gc()
    m2 = memuse()
    println("Memory consumption $(m2-m1) Mb and Time $(time)")
end

println("Vectorized")
t(1)
t(1)

println("Scalar 1")
t(2)
t(2)

println("Scalar 2")
t(3)
t(3)

println("Low-level API")
t(4)
t(4)

Vectorized
Memory consumption 1079 Mb and Time 14.493644756
Memory consumption 1023 Mb and Time 13.870267812
Scalar 1
Memory consumption 1107 Mb and Time 7.674387291
Memory consumption 1119 Mb and Time 8.528182488
Scalar 2
Memory consumption 1130 Mb and Time 8.32419865
Memory consumption 1132 Mb and Time 8.495367176
Low-level API
Memory consumption 327 Mb and Time 3.042267338
Memory consumption 355 Mb and Time 2.844282922

[mlubin]

The inconsistent performance of the scalar case suggests issues in Julia with type inference. Try using @code_warntype.

[Thuener]

The most important problem here is the big difference between memory consumption, the difference in performance should be an consequence of that.

[mlubin]

We store linear constraints as vectors of sparse affine expressions. For each coefficient we additionally store the corresponding Variable (an integer column index and a pointer to the model), so 2.5x more memory than storing the dense matrix on its own is expected. JuMP is designed for sparse problems, and I don't see our data structures changing anytime soon.

Additionally, there will be two copies of the constraint matrix kept in memory: JuMP's internal copy and the solver's internal copy. If this causes a memory bottleneck for you, you should consider not using JuMP.

[Thuener]

Ok, I see that JuMP is not created for that but why not have a special function to add constraints without storing any information about them. I'm not the only one with this problem, many of my collegues have similar problems with memory consumption or perfomance, most of them use with benders decompositions.

[mlubin]

If JuMP has an internal model loaded, then you're free to call MathProgBase.addconstr! to add constraints that JuMP won't keep track of. You should be careful though to not add more constraints through JuMP once you start doing this, because the indices of the constraints will be mismatched and dual values on the constraints will not be correct.