Make presolvers and integrations instance-level

[gianlucagallo]

Hi,
I’m working on a parallel optimization workflow where different threads, or even different phases of the same workflow, need to configure and use distinct solver setups (different presolvers, different integrations, etc.).

Right now, ExpressionsBasedModel uses static methods for controlling presolvers and solver integrations, such as:

ExpressionsBasedModel.clearPresolvers();
ExpressionsBasedModel.resetPresolvers();
ExpressionsBasedModel.clearIntegrations();
ExpressionsBasedModel.addIntegration(LinearSolver.INTEGRATION);

Feature request
Would it be possible to refactor presolvers and solver integration handling so that they are instance-level rather than static/global?

This change would make the library much more flexible and suitable for concurrent optimization tasks where different models require different solver strategies and need to run in parallel.

Thank you.

[apete]

It is of course possible, and it's kind of on my todo. The main reason it hasn't been done yet is the presumed performance impact on the IntegerSolver. The IntegerSolver relies on making a large number of shallow copies of the model. I'd prefer to not complicate this in any way. (I have plans to separate these two concerns. When/if that's done I see no problem.)

Exactly what do you need? There already exists features to configure solvers and integrations. Making use of this, and possibly extending it, may be a more direct alternative for you. Perhaps that's also the correct place for this.

[gianlucagallo]

My use case is the following: in my workflow, two independent problems are prepared. Their solution requires several optimization steps in which variables and objective functions are modified, and simplified feasibility checks are also performed. Throughout these steps, presolvers are enabled or disabled, and different solvers are selected depending on the phase (e.g., quadratic problems are handled using native solvers, while feasibility checks use your integrated LinearSolver, mainly for performance reasons)

At the moment, these two independent problems must be solved sequentially, because the solver switch cannot be executed in a multithreaded environment.
Do you think there is a way for me to handle them in parallel without modifying the ExpressionsBasedModel static integration?

[apete]

Hard to follow exactly what you need, but I do of course understand the limitations the static configurations impose.

Are you using presolvers you built yourself or just the default ones? Which ones are problematic?

Are you aware that a solver/integration will only be used if its isCapable(...) method return true, and that you can limit this further by setting a withCapabilityPredicate(...)?

If you implement your own ExpressionsBasedModel.Integration subclass you can have it delegate to various other integrations and store the choices/switches using ExpressionsBasedModel.IntegrationProperty.

How far does that get you?

[gianlucagallo]

Exactly, and that approach is almost perfect.
To control the solver selection based on the specific problem instance, I am indeed considering using isCapable/withCapabilityPredicate, and that might actually solve most of the issue.

The remaining point is presolver selection: presolvers don’t seem to offer an equally flexible mechanism. For example, ZERO_ONE_TWO is invoked automatically whenever PRESOLVERS.size() > 0, and I have no way to disable it selectively other than removing all presolvers altogether.

I am not using any custom presolvers, and I’m currently experiencing some issues with the integrated ones due to a bug in the handling of quadratic expressions (also in version 56.1.1). I’ll open a dedicated issue for that shortly.

[apete]

Sounds like isCapable/withCapabilityPredicate and fixing that bug could solve your problems. Please open an issue for that bug.

Most likely there will be some redesign of ExpressionsBasedModel and all its features, but I'd rather not rush this.