Special-case NW-PFSP for CP Optimizer (permutation constraints)

Author: leonlan

benchmark.py

@@ -3,7 +3,6 @@
 from functools import partial
 from multiprocessing import cpu_count
 from pathlib import Path
-from typing import Optional
 
 import numpy as np
 import tomli
@@ -115,10 +114,10 @@ def _solve(
     time_limit: float,
     display: bool,
     num_workers_per_instance: int,
-    config_loc: Optional[Path],
-    sol_dir: Optional[Path],
+    config_loc: Path | None,
+    sol_dir: Path | None,
     permutation_max_jobs: int,
-) -> Optional[tuple[str, str, float, float, float]]:
+) -> tuple[str, str, float, float, float] | None:
     """
     Solves a single problem instance.
     """
@@ -128,11 +127,12 @@ def _solve(
     else:
         params = {}
 
-    data = read(instance_loc, problem_variant)
-    if data.constraints.same_sequence:
+    data = read(instance_loc, problem_variant, solver)
+    if data.constraints.same_sequence and problem_variant != ProblemVariant.NW_PFSP:
         # For permutation problems we skip instances that are too large.
         # We have to recompute the number of jobs because we no longer
         # create jobs if they are not relevant to the problem.
+        # NW-PFSP is exempt: it is solved at all sizes regardless of solver.
         num_factories = data.num_modes // data.num_tasks
         num_stages = data.num_machines // num_factories
         num_jobs = data.num_tasks // num_stages
@@ -161,7 +161,7 @@ def _solve(
 
 
 def _check_cpu_usage(
-    num_parallel_instances: int, num_workers_per_instance: Optional[int]
+    num_parallel_instances: int, num_workers_per_instance: int | None
 ):
     """
     Warns if the number of workers per instance times the number of parallel

read/machine.py

@@ -211,10 +211,16 @@ def parse_osp(cls, loc: Path):
         return instance
 
     @classmethod
-    def parse_nw_pfsp(cls, loc: Path):
+    def parse_nw_pfsp(cls, loc: Path, solver: str | None = None):
         instance = cls.parse_npfsp(loc)
         instance.no_wait = True
-        # TODO might add permutation here for CP Optimizer?
+
+        if solver == "cpoptimizer":
+            # For NW-PFSP, only CP Optimizer benefits from explicit permutation
+            # constraints. For OR-Tools the no-wait constraints already pin the
+            # sequence, so adding them only slows it down.
+            instance.permutation = list(pairwise(range(instance.num_machines)))
+
         return instance
 
     @classmethod

read/read.py

@@ -6,16 +6,23 @@
 from pyjobshop import ProblemData, read as _read
 
 
-def read(loc: Path, problem: ProblemVariant) -> ProblemData:
+def read(
+    loc: Path, problem: ProblemVariant, solver: str | None = None
+) -> ProblemData:
     """
     Reads a problem instance from file and returns a ProblemData instance.
+
+    The ``solver`` argument is passed to the parsers to apply solver-specific
+    modeling choices (e.g. the NW-PFSP permutation constraints).
     """
     machine_variants = {
         ProblemVariant.JSP: MachineInstance.parse_jsp,
         ProblemVariant.FJSP: MachineInstance.parse_fjsp,
         ProblemVariant.HFSP: MachineInstance.parse_hfsp,
         ProblemVariant.NPFSP: MachineInstance.parse_npfsp,
-        ProblemVariant.NW_PFSP: MachineInstance.parse_nw_pfsp,
+        ProblemVariant.NW_PFSP: partial(
+            MachineInstance.parse_nw_pfsp, solver=solver
+        ),
         ProblemVariant.PMP: MachineInstance.parse_pmp,
         ProblemVariant.OSP: MachineInstance.parse_osp,
         # Permutation machine scheduling