[Clp] warmstarting problems

[rm zuckerberg]

Hello.

I have an algorithm that generates lp's sequentially in such a way that
each lp's optimal solution is feasible - and often near optimal - for the
next lp to be generated. As there are typically many lp's generated, it is
very desirable to be able to warmstart each lp with the previous one's
solution.

I have been using the setColSolution() function to populate the warm start,
and then solving with primal using the initialSolve() function.

While this usually works well, I've found that with a number of the more
numerically challenging problems, it often takes dramatically longer to
solve with the warmstart than it does to solve from scratch - even though
the values pass gets a near optimal solution almost right away.

Here is an lp (mps is in IEEE hex format)
https://1drv.ms/u/s!AuXES_soqYA6gsAR9IBKZSi1Z82KCA?e=y8t6nX

and here is a warmstart vector (in binary and in text)
https://1drv.ms/u/s!AuXES_soqYA6gsAQWp-V8GtrmWVpTw?e=eWNhN4
https://1drv.ms/t/s!AuXES_soqYA6gsATvj-8ChVN2fuKXg?e=RdOyIS

and here is the output log (for the warmstarted version with presolve)
https://1drv.ms/u/s!AuXES_soqYA6gsASU-UfwVfpXo7U3w?e=7vpbOi

In this case with the warmstart, both with and without presolve I stopped
the run after over an hour without a solution (despite being near optimal
from the warmstart after 3 seconds), while from scratch it takes about 2.5
minutes with presolve and 3.3 without.

These warmstarted solutions are typically not basic, but - while I'm not
posting any examples here - I observed the same thing to happen even when I
supplied a starting basis.

It may be that this is hit or miss, as sometimes turning on presolve speeds
it up a lot, and sometimes it slows it down a lot, and sometimes there is
different behavior for different solve function calls. For example, for
this problem and warmstart (in binary and in text)
https://1drv.ms/u/s!AuXES_soqYA6gsAWWWSp-0iB2IN-jw?e=Aau8Hr
https://1drv.ms/u/s!AuXES_soqYA6gsAUYqgIYROEpGxkXg?e=apXJDa
https://1drv.ms/t/s!AuXES_soqYA6gsAVsr5_oIx85LEuGQ?e=YqV4br

using the function calls:

ClpPresolve presolveInfo;
ClpSimplex* presolvedModel = presolveInfo.presolvedModel(model);
presolvedModel->primal(1);
presolveInfo.postsolve(true);
model.primal(1);

I stopped the run after 27000 seconds with no solution, while using
initialSolve() and the warmstart as above it took around 4.5 minutes to
solve. From scratch it took just under 2 minutes with presolve and just
over 1 without.

Are there any settings that I could use that may assist with this?

I'm running on Windows 10 and compiling Clp 1.17.6 with Visual Studio 2019.

Thanks very much!

Mark Zuckerberg
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://list.coin-or.org/pipermail/clp/attachments/20200827/dfff21b5/attachment.html>