Distributed MILP Solving: How a Node-to-Node Framework Scales to 1000+ ProcessesDistributed MILP Solving: How a Node-to-Node Framework Scales to 1000+ ProcessesDistributed MILP Solving: How a Node-to-Node Framework Scales to 1000+ Processes

Supervisor Worker Paradigm & Subtree level Parallelism

N2N uses a supervisor worker model: one "supervisor" node manages task assignment; many "worker" nodes solve subproblems.
Parallelism is at the subtree/node level: individual B&B nodes are distributed across machines.

Two Modes: Deterministic and Non deterministic

Non deterministic mode maximizes throughput: tasks dispatched as fast as possible. Great for when you just want a solution quickly.
Deterministic mode: ensures reproducible execution order. They do this via a sliding window scheduling algorithm: tasks (B&B nodes + metadata like incumbent bound) are generated and solved in a fixed, globally agreed order. As long as the base solver is deterministic, the overall result is deterministic.

Exploiting Solver & Cluster Capabilities

N2N doesn't just naively split the B&B tree - it leverages primal heuristics, constraint programming style search, and multiple presolve strategies before distributing tasks. That helps balance load better across a messy, skewed search tree.
They transfer presolved instances using a standardized format (MPS), minimizing communication overhead and avoiding fragile memory serialization hacks common in other frameworks.
The framework adapts solver parameters and worker activity based on problem characteristics and dynamic cluster load.

Plug and Play Integration

With 1,000 MPI processes on two different cluster types (x86 and Kunpeng), nondeterministic N2N SCIP achieves speedups of 22.5× and 12.7×, respectively. That corresponds to roughly 2× faster than ParaSCIP under the same conditions.
Even in deterministic mode (which often comes at performance cost), N2N SCIP still exhibits "significant performance improvements over ParaSCIP across different process counts and cluster hardware."
They also show portability: N2N HiGHS works, underscoring that N2N isn't tied to a single solver - a big win for flexibility.

# Example 1: Non deterministic distributed solve
from n2n import Supervisor, WorkerMPI

supervisor = Supervisor(problem_file="big_model.mps")
supervisor.presolve()  # runs presolve strategies, writes presolved instance

# Launch 500 workers (MPI or similar cluster launch assumed)
workers = [WorkerMPI() for _ in range(500)]

supervisor.distribute(workers, mode="non_deterministic")
solution = supervisor.wait_for_best_solution(timeout=3600)  # 1h limit
print("Best objective:", solution.obj, "time:", solution.time)

# Example 2: Deterministic run (full reproducibility)
supervisor = Supervisor(problem_file="big_model.mps")
supervisor.presolve()
supervisor.distribute(workers, mode="deterministic", window_size=1000)  # sliding-window width
solution = supervisor.wait_for_termination()  # runs to optimality or full tree explored
print("Optimal:", solution.optimal, "Objective:", solution.obj)

# Example 3: Command-line launching (e.g. on HPC job scheduler)
n2n_supervisor --input big_model.mps --mode deterministic --workers 1000
n2n_worker --join_cluster <supervisor_address>

Production ready? Yes - this framework ticks the right boxes: scalability, reproducibility (if needed), solver agnosticism, and demonstrable speed gains.
Use Cases: Very large scheduling, routing, resource allocation problems; batch solving large MILPs; distributed optimization in cloud/HPC contexts; production operations research at scale.
Caveats: Gains rely on having many compute nodes (hundreds to 1,000+) and cluster infrastructure (MPI or equivalent). Communication overhead, cluster latency, and I/O (MPS file transfer) still matter - but the authors optimized for that. Also, deterministic mode comes with added synchronization overhead, so non deterministic mode is preferable when you only care about solution speed, not exact reproducibility.
What I'd check before launching: cluster network bandwidth/latency; whether your MILP instance benefits from presolve + CP heuristics; how base solver behaves under repeated parallel subproblem solving (some solvers may have nondeterministic internals).