Significant difference in SCIP solving time between JuMP and Rust (`russcip`)

Specific Domains Optimization (Mathematical)
1

Hi all,

I’ve noticed a large difference in solving time when using SCIP through JuMP in Julia versus using the russcip crate in Rust, and I’m hoping someone can help explain why.

:puzzle_piece: Context

I’m solving a MIQP problem from an .mps file using SCIP. Here’s the Julia function I wrote using JuMP:

using JuMP
using SCIP

function run_model(modelpath)
    model = read_from_file(modelpath)
    set_optimizer(model, SCIP.Optimizer)
    optimize!(model)
end

Using this, the problem solves in around 120 seconds, according to the “Solving Time (sec)” reported by SCIP.

To compare, I reimplemented the same workflow in Rust using russcip:

fn read_and_solve_model(filepath: &str) -> Model<Solved> {
    let model = Model::new()
        .include_default_plugins()
        .read_prob(filepath)
        .expect("Failed to read model file");

    model.solve()
}

Model and Model<Solved> come from the russcip crate.

With this Rust version, the same problem solves in less than 10 seconds, again using SCIP’s own “Solving Time” metric.

:red_question_mark: Question

That’s a dramatic difference—over 10× faster in Rust—so I’m wondering what could explain it.

My first guess was include_default_plugins() might add some useful features, but I assumed JuMP would also initialize SCIP with a reasonable default set of plugins (though perhaps not exactly the same ones?).

Are there known differences between how SCIP is initialized/configured in JuMP vs russcip? Is it possible that JuMP disables certain presolvers, heuristics, or plugin features by default?

:test_tube: Notes

  • The .mps file is identical in both runs.
  • The hardware and OS are the same.
  • Both runs use the “Solving Time (sec)” from SCIP output, so the measurement should be consistent.
  • I’m using the latest stable versions of JuMP, SCIP.jl, and russcip.

Thanks in advance for any insights!

2

What’s your machine? I wonder if the difference is entirely in the builds of SCIP used by the julia package vs the rust package. Profiling the two executions would shed some light.

3

I have a laptop with Arch Linux (always up to date) on it and a Ryzen 7 7840U inside. The version of SCIP I’m using is the same one in both cases, the one packaged in the official’s repo of Arch.

What information should I search for when profiling ?