From 57f02fd017f758aa8cc569541e2ab5568adac8a7 Mon Sep 17 00:00:00 2001 From: Vittorio Distefano Date: Tue, 10 Nov 2026 03:32:53 +0100 Subject: [PATCH] refactor(adapters): keep the native adapters' lib.rs to declarations Each native SolverForge adapter held its whole PyO3 entry point in lib.rs. The adapter code (input/output types, plan building, the solve call, the #[pyfunction]/#[pymodule] entry points and their tests) now lives in src/adapter.rs; lib.rs declares modules and the planning_model! manifest only. The nurse-rostering telemetry section is built in its own function, so no json! literal needs #![recursion_limit = "256"]. The fair-start scanner reads the same start-shape assertions from adapter.rs. The JSON each adapter returns is unchanged. Closes #5 --- .../solver/solverforge/src/adapter.rs | 251 ++++++++++ .../src/{lib_tests.rs => adapter_tests.rs} | 0 .../cvrp_bench/solver/solverforge/src/lib.rs | 249 +--------- .../scripts/verify_model_parity.py | 2 +- .../solver/solverforge_nrp/src/adapter.rs | 433 ++++++++++++++++++ .../solver/solverforge_nrp/src/lib.rs | 424 +---------------- .../solver/solverforge_jssp/src/adapter.rs | 258 +++++++++++ .../solver/solverforge_jssp/src/lib.rs | 256 +---------- scripts/verify_fair_start.py | 6 +- 9 files changed, 949 insertions(+), 930 deletions(-) create mode 100644 list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/adapter.rs rename list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/{lib_tests.rs => adapter_tests.rs} (100%) create mode 100644 scalar-variable/employee-scheduling/src/employee_scheduling_bench/solver/solverforge_nrp/src/adapter.rs create mode 100644 scalar-variable/job-shop-scheduling/src/job_shop_bench/solver/solverforge_jssp/src/adapter.rs diff --git a/list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/adapter.rs b/list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/adapter.rs new file mode 100644 index 0000000..137d66d --- /dev/null +++ b/list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/adapter.rs @@ -0,0 +1,251 @@ +//! PyO3 entry point for the CVRP benchmark: reads an instance as JSON, solves +//! it with SolverForge, and returns routes, telemetry and the fair-start witness. + +use crate::{Customer, CvrpPlan, Route}; +use std::collections::BTreeMap; +use std::sync::Arc; + +use pyo3::prelude::*; +use serde::{Deserialize, Serialize}; +use solverforge::cvrp::ProblemData; +use solverforge::{PhaseTelemetry, SolverEvent, SolverManager, SolverTelemetry}; + +static MANAGER: SolverManager = SolverManager::new(); + +#[derive(Deserialize)] +struct InstanceInput { + dimension: usize, + capacity: i32, + demand: Vec, + depot: usize, + distance_matrix: Vec>, +} + +#[derive(Serialize)] +struct SolutionOutput { + routes: Vec>, + cost: i64, + fair_start_witness: FairStartWitness, + solverforge_telemetry: TelemetryOutput, +} + +/// Search counters the thread study reads to explain a cost difference. +#[derive(Serialize)] +struct TelemetryOutput { + move_threads: usize, + elapsed_ms: u128, + step_count: u64, + moves_generated: u64, + moves_evaluated: u64, + moves_speculative: u64, + moves_applied: u64, + generation_time_ms: u128, + evaluation_time_ms: u128, + phases: Vec, +} + +/// One phase's share of the run, so the study can read local search alone. +#[derive(Serialize)] +struct PhaseOutput { + phase_type: String, + elapsed_ms: u128, + step_count: u64, + moves_evaluated: u64, + moves_speculative: u64, + generation_time_ms: u128, + evaluation_time_ms: u128, +} + +impl PhaseOutput { + fn new(phase: &PhaseTelemetry) -> Self { + Self { + phase_type: phase.phase_type.clone(), + elapsed_ms: phase.elapsed.as_millis(), + step_count: phase.step_count, + moves_evaluated: phase.moves_evaluated, + moves_speculative: phase.moves_speculative, + generation_time_ms: phase.generation_time.as_millis(), + evaluation_time_ms: phase.evaluation_time.as_millis(), + } + } +} + +impl TelemetryOutput { + fn new(move_threads: usize, telemetry: &SolverTelemetry) -> Self { + Self { + move_threads, + elapsed_ms: telemetry.elapsed.as_millis(), + step_count: telemetry.step_count, + moves_generated: telemetry.moves_generated, + moves_evaluated: telemetry.moves_evaluated, + moves_speculative: telemetry.moves_speculative, + moves_applied: telemetry.moves_applied, + generation_time_ms: telemetry.generation_time.as_millis(), + evaluation_time_ms: telemetry.evaluation_time.as_millis(), + phases: telemetry.phases.iter().map(PhaseOutput::new).collect(), + } + } +} + +#[derive(Serialize)] +struct FairStartWitness { + adapter_hint_count: usize, + preliminary_solve_count: usize, + fallback_solution_enabled: bool, + preassigned_scalar_variables: usize, + prefilled_list_variables: usize, +} + +fn build_plan(input: InstanceInput, time_limit_secs: u64, move_threads: usize) -> CvrpPlan { + let customer_node_ids: Vec = (0..input.dimension) + .filter(|&node_idx| node_idx != input.depot) + .collect(); + let distance_matrix = input.distance_matrix; + let travel_times = distance_matrix.clone(); + + let shared = Arc::new(ProblemData { + capacity: input.capacity as i64, + depot: input.depot, + demands: input.demand, + distance_matrix, + time_windows: vec![(0, i64::MAX); input.dimension], + service_durations: vec![0; input.dimension], + travel_times, + vehicle_departure_time: 0, + }); + let data_addr = Arc::as_ptr(&shared) as usize; + + let customers = customer_node_ids + .iter() + .copied() + .map(|node_id| Customer { id: node_id }) + .collect(); + + let routes = (0..customer_node_ids.len()) + .map(|id| Route { + id, + visits: Vec::new(), + data_addr, + }) + .collect(); + + CvrpPlan { + customers, + customer_values: customer_node_ids, + routes, + score: None, + shared, + time_limit_secs, + move_threads, + } +} + +fn ensure_complete_customer_assignment(plan: &CvrpPlan) -> Result<(), String> { + let expected = plan.customer_values.iter().copied().fold( + BTreeMap::::new(), + |mut counts, customer| { + *counts.entry(customer).or_default() += 1; + counts + }, + ); + let assigned = plan + .routes + .iter() + .flat_map(|route| &route.visits) + .copied() + .fold(BTreeMap::::new(), |mut counts, customer| { + *counts.entry(customer).or_default() += 1; + counts + }); + if assigned != expected { + return Err(format!( + "SolverForge CVRP returned an incomplete customer assignment: expected={expected:?}, assigned={assigned:?}" + )); + } + Ok(()) +} + +#[pyfunction] +#[pyo3(signature = (instance_json, time_limit, move_threads = 1))] +fn solve_cvrp(instance_json: &str, time_limit: u64, move_threads: usize) -> PyResult { + let input: InstanceInput = serde_json::from_str(instance_json) + .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; + let plan = build_plan(input, time_limit, move_threads); + let fair_start_witness = FairStartWitness { + adapter_hint_count: 0, + preliminary_solve_count: 0, + fallback_solution_enabled: false, + preassigned_scalar_variables: 0, + prefilled_list_variables: plan + .routes + .iter() + .filter(|route| !route.visits.is_empty()) + .count(), + }; + let (job_id, mut receiver) = MANAGER + .solve(plan) + .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?; + + let solved = loop { + match receiver.blocking_recv() { + Some(SolverEvent::Completed { solution, metadata }) => { + break Ok((solution, metadata.telemetry)) + } + Some(SolverEvent::Cancelled { metadata }) => { + break Err(pyo3::exceptions::PyRuntimeError::new_err(format!( + "SolverForge job {} was cancelled ({:?})", + metadata.job_id, metadata.terminal_reason + ))) + } + Some(SolverEvent::Failed { metadata, error }) => { + break Err(pyo3::exceptions::PyRuntimeError::new_err(format!( + "SolverForge job {} failed: {}", + metadata.job_id, error + ))) + } + Some(SolverEvent::Progress { .. }) + | Some(SolverEvent::BestSolution { .. }) + | Some(SolverEvent::PauseRequested { .. }) + | Some(SolverEvent::Paused { .. }) + | Some(SolverEvent::Resumed { .. }) => {} + None => { + break Err(pyo3::exceptions::PyRuntimeError::new_err( + "SolverForge event stream closed before a terminal event", + )) + } + } + }; + + let delete_result = MANAGER.delete(job_id).map_err(|e| { + pyo3::exceptions::PyRuntimeError::new_err(format!( + "failed to delete SolverForge job {}: {}", + job_id, e + )) + }); + + let (solved, telemetry) = solved?; + delete_result?; + ensure_complete_customer_assignment(&solved) + .map_err(pyo3::exceptions::PyValueError::new_err)?; + let routes = solved.materialized_routes(); + let cost = solved.total_cost(); + + let output = SolutionOutput { + routes, + cost, + fair_start_witness, + solverforge_telemetry: TelemetryOutput::new(move_threads, &telemetry), + }; + serde_json::to_string(&output) + .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string())) +} + +#[pymodule] +fn solverforge_cvrp(m: &Bound<'_, PyModule>) -> PyResult<()> { + m.add_function(wrap_pyfunction!(solve_cvrp, m)?)?; + Ok(()) +} + +#[cfg(test)] +#[path = "adapter_tests.rs"] +mod tests; diff --git a/list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/lib_tests.rs b/list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/adapter_tests.rs similarity index 100% rename from list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/lib_tests.rs rename to list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/adapter_tests.rs diff --git a/list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/lib.rs b/list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/lib.rs index fcdd491..55e81ea 100644 --- a/list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/lib.rs +++ b/list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/lib.rs @@ -9,251 +9,4 @@ solverforge::planning_model! { pub use domain::CvrpPlan; pub use domain::Route; } - -#[cfg(test)] -#[path = "lib_tests.rs"] -mod tests; - -use std::collections::BTreeMap; -use std::sync::Arc; - -use pyo3::prelude::*; -use serde::{Deserialize, Serialize}; -use solverforge::cvrp::ProblemData; -use solverforge::{PhaseTelemetry, SolverEvent, SolverManager, SolverTelemetry}; - -static MANAGER: SolverManager = SolverManager::new(); - -#[derive(Deserialize)] -struct InstanceInput { - dimension: usize, - capacity: i32, - demand: Vec, - depot: usize, - distance_matrix: Vec>, -} - -#[derive(Serialize)] -struct SolutionOutput { - routes: Vec>, - cost: i64, - fair_start_witness: FairStartWitness, - solverforge_telemetry: TelemetryOutput, -} - -/// Search counters the thread study reads to explain a cost difference. -#[derive(Serialize)] -struct TelemetryOutput { - move_threads: usize, - elapsed_ms: u128, - step_count: u64, - moves_generated: u64, - moves_evaluated: u64, - moves_speculative: u64, - moves_applied: u64, - generation_time_ms: u128, - evaluation_time_ms: u128, - phases: Vec, -} - -/// One phase's share of the run, so the study can read local search alone. -#[derive(Serialize)] -struct PhaseOutput { - phase_type: String, - elapsed_ms: u128, - step_count: u64, - moves_evaluated: u64, - moves_speculative: u64, - generation_time_ms: u128, - evaluation_time_ms: u128, -} - -impl PhaseOutput { - fn new(phase: &PhaseTelemetry) -> Self { - Self { - phase_type: phase.phase_type.clone(), - elapsed_ms: phase.elapsed.as_millis(), - step_count: phase.step_count, - moves_evaluated: phase.moves_evaluated, - moves_speculative: phase.moves_speculative, - generation_time_ms: phase.generation_time.as_millis(), - evaluation_time_ms: phase.evaluation_time.as_millis(), - } - } -} - -impl TelemetryOutput { - fn new(move_threads: usize, telemetry: &SolverTelemetry) -> Self { - Self { - move_threads, - elapsed_ms: telemetry.elapsed.as_millis(), - step_count: telemetry.step_count, - moves_generated: telemetry.moves_generated, - moves_evaluated: telemetry.moves_evaluated, - moves_speculative: telemetry.moves_speculative, - moves_applied: telemetry.moves_applied, - generation_time_ms: telemetry.generation_time.as_millis(), - evaluation_time_ms: telemetry.evaluation_time.as_millis(), - phases: telemetry.phases.iter().map(PhaseOutput::new).collect(), - } - } -} - -#[derive(Serialize)] -struct FairStartWitness { - adapter_hint_count: usize, - preliminary_solve_count: usize, - fallback_solution_enabled: bool, - preassigned_scalar_variables: usize, - prefilled_list_variables: usize, -} - -fn build_plan(input: InstanceInput, time_limit_secs: u64, move_threads: usize) -> CvrpPlan { - let customer_node_ids: Vec = (0..input.dimension) - .filter(|&node_idx| node_idx != input.depot) - .collect(); - let distance_matrix = input.distance_matrix; - let travel_times = distance_matrix.clone(); - - let shared = Arc::new(ProblemData { - capacity: input.capacity as i64, - depot: input.depot, - demands: input.demand, - distance_matrix, - time_windows: vec![(0, i64::MAX); input.dimension], - service_durations: vec![0; input.dimension], - travel_times, - vehicle_departure_time: 0, - }); - let data_addr = Arc::as_ptr(&shared) as usize; - - let customers = customer_node_ids - .iter() - .copied() - .map(|node_id| Customer { id: node_id }) - .collect(); - - let routes = (0..customer_node_ids.len()) - .map(|id| Route { - id, - visits: Vec::new(), - data_addr, - }) - .collect(); - - CvrpPlan { - customers, - customer_values: customer_node_ids, - routes, - score: None, - shared, - time_limit_secs, - move_threads, - } -} - -fn ensure_complete_customer_assignment(plan: &CvrpPlan) -> Result<(), String> { - let expected = plan.customer_values.iter().copied().fold( - BTreeMap::::new(), - |mut counts, customer| { - *counts.entry(customer).or_default() += 1; - counts - }, - ); - let assigned = plan - .routes - .iter() - .flat_map(|route| &route.visits) - .copied() - .fold(BTreeMap::::new(), |mut counts, customer| { - *counts.entry(customer).or_default() += 1; - counts - }); - if assigned != expected { - return Err(format!( - "SolverForge CVRP returned an incomplete customer assignment: expected={expected:?}, assigned={assigned:?}" - )); - } - Ok(()) -} - -#[pyfunction] -#[pyo3(signature = (instance_json, time_limit, move_threads = 1))] -fn solve_cvrp(instance_json: &str, time_limit: u64, move_threads: usize) -> PyResult { - let input: InstanceInput = serde_json::from_str(instance_json) - .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string()))?; - let plan = build_plan(input, time_limit, move_threads); - let fair_start_witness = FairStartWitness { - adapter_hint_count: 0, - preliminary_solve_count: 0, - fallback_solution_enabled: false, - preassigned_scalar_variables: 0, - prefilled_list_variables: plan - .routes - .iter() - .filter(|route| !route.visits.is_empty()) - .count(), - }; - let (job_id, mut receiver) = MANAGER - .solve(plan) - .map_err(|e| pyo3::exceptions::PyRuntimeError::new_err(e.to_string()))?; - - let solved = loop { - match receiver.blocking_recv() { - Some(SolverEvent::Completed { solution, metadata }) => { - break Ok((solution, metadata.telemetry)) - } - Some(SolverEvent::Cancelled { metadata }) => { - break Err(pyo3::exceptions::PyRuntimeError::new_err(format!( - "SolverForge job {} was cancelled ({:?})", - metadata.job_id, metadata.terminal_reason - ))) - } - Some(SolverEvent::Failed { metadata, error }) => { - break Err(pyo3::exceptions::PyRuntimeError::new_err(format!( - "SolverForge job {} failed: {}", - metadata.job_id, error - ))) - } - Some(SolverEvent::Progress { .. }) - | Some(SolverEvent::BestSolution { .. }) - | Some(SolverEvent::PauseRequested { .. }) - | Some(SolverEvent::Paused { .. }) - | Some(SolverEvent::Resumed { .. }) => {} - None => { - break Err(pyo3::exceptions::PyRuntimeError::new_err( - "SolverForge event stream closed before a terminal event", - )) - } - } - }; - - let delete_result = MANAGER.delete(job_id).map_err(|e| { - pyo3::exceptions::PyRuntimeError::new_err(format!( - "failed to delete SolverForge job {}: {}", - job_id, e - )) - }); - - let (solved, telemetry) = solved?; - delete_result?; - ensure_complete_customer_assignment(&solved) - .map_err(pyo3::exceptions::PyValueError::new_err)?; - let routes = solved.materialized_routes(); - let cost = solved.total_cost(); - - let output = SolutionOutput { - routes, - cost, - fair_start_witness, - solverforge_telemetry: TelemetryOutput::new(move_threads, &telemetry), - }; - serde_json::to_string(&output) - .map_err(|e| pyo3::exceptions::PyValueError::new_err(e.to_string())) -} - -#[pymodule] -fn solverforge_cvrp(m: &Bound<'_, PyModule>) -> PyResult<()> { - m.add_function(wrap_pyfunction!(solve_cvrp, m)?)?; - Ok(()) -} +mod adapter; diff --git a/scalar-variable/employee-scheduling/scripts/verify_model_parity.py b/scalar-variable/employee-scheduling/scripts/verify_model_parity.py index cb6c796..678dc5a 100755 --- a/scalar-variable/employee-scheduling/scripts/verify_model_parity.py +++ b/scalar-variable/employee-scheduling/scripts/verify_model_parity.py @@ -92,7 +92,7 @@ def _source_checks(repo_root: Path) -> list[SourceCheck]: timefold_main = timefold / "Main.java" timefold_assignment = timefold / "domain" / "ShiftAssignment.java" solverforge = employee_src / "solver" / "solverforge_nrp" / "src" - solverforge_lib = solverforge / "lib.rs" + solverforge_lib = solverforge / "adapter.rs" solverforge_domain = solverforge / "domain.rs" solverforge_constraints = solverforge / "constraints.rs" solverforge_py = employee_src / "solver" / "solverforge_py.py" diff --git a/scalar-variable/employee-scheduling/src/employee_scheduling_bench/solver/solverforge_nrp/src/adapter.rs b/scalar-variable/employee-scheduling/src/employee_scheduling_bench/solver/solverforge_nrp/src/adapter.rs new file mode 100644 index 0000000..f5a0cda --- /dev/null +++ b/scalar-variable/employee-scheduling/src/employee_scheduling_bench/solver/solverforge_nrp/src/adapter.rs @@ -0,0 +1,433 @@ +//! PyO3 entry point for the nurse-rostering benchmark: reads an instance as +//! JSON, solves it with SolverForge, and returns assignments, telemetry and the +//! fair-start witness. + +use crate::solver::solve; +use crate::{ + ContractData, NrpPlan, NrpShift, NurseData, NurseHistoryData, NurseIndex, NurseShiftTypeIndex, + ProblemData, ShiftTypeData, +}; +use pyo3::prelude::*; +use serde::Deserialize; +use solverforge::Analyzable; + +use solverforge::SolverTelemetry; + +#[derive(Deserialize)] +struct NurseInput { + id: String, + contract_idx: usize, + skills: Vec, +} + +#[derive(Deserialize)] +struct ShiftInput { + week: usize, + day: usize, + shift_type_idx: usize, + skill_idx: usize, + is_minimum: bool, +} + +#[derive(Deserialize)] +struct ForbiddenInput { + preceding: usize, + succeeding: Vec, +} + +#[derive(Deserialize)] +struct ShiftOffInput { + nurse_idx: usize, + global_day: usize, + shift_type_idx: usize, +} + +#[derive(Deserialize)] +struct HistoryInput { + nurse_idx: usize, + num_assignments: i64, + num_working_weekends: i64, + last_shift_type_idx: Option, + num_consecutive_assignments: i64, + num_consecutive_working: i64, + num_consecutive_off: i64, +} + +#[derive(Deserialize)] +struct InstanceInput { + nurses: Vec, + contracts: Vec, + shift_types: Vec, + forbidden: Vec, + shift_off_requests: Vec, + nurse_history: Vec, + shifts: Vec, + num_weeks: usize, + skill_names: Vec, + shift_type_names: Vec, + nurse_names: Vec, +} + +fn do_solve(instance_json: &str, time_limit: u64, move_threads: usize) -> Result { + let input: InstanceInput = + serde_json::from_str(instance_json).map_err(|e| format!("Invalid JSON: {}", e))?; + + let num_shift_types = input.shift_types.len(); + let nurses: Vec = input + .nurses + .into_iter() + .enumerate() + .map(|(i, n)| NurseData { + index: i, + id: n.id, + contract_idx: n.contract_idx, + skills: n.skills, + }) + .collect(); + + let mut nurse_history_by_index: Vec> = vec![None; nurses.len()]; + for h in input.nurse_history { + if h.nurse_idx >= nurses.len() { + return Err(format!( + "Nurse history index {} is out of range", + h.nurse_idx + )); + } + nurse_history_by_index[h.nurse_idx] = Some(NurseHistoryData { + nurse_idx: h.nurse_idx, + num_assignments: h.num_assignments, + num_working_weekends: h.num_working_weekends, + last_shift_type_idx: h.last_shift_type_idx, + num_consecutive_assignments: h.num_consecutive_assignments, + num_consecutive_working: h.num_consecutive_working, + num_consecutive_off: h.num_consecutive_off, + }); + } + let nurse_history: Vec = nurse_history_by_index + .into_iter() + .enumerate() + .map(|(nurse_idx, history)| { + history.ok_or_else(|| format!("Missing history for nurse index {}", nurse_idx)) + }) + .collect::>()?; + + let forbidden: Vec<(usize, Vec)> = input + .forbidden + .into_iter() + .map(|f| (f.preceding, f.succeeding)) + .collect(); + + let shift_off_requests: Vec<(usize, usize, usize)> = input + .shift_off_requests + .into_iter() + .map(|s| (s.nurse_idx, s.global_day, s.shift_type_idx)) + .collect(); + let total_days = input.num_weeks * 7; + let mut shift_off_requests_by_nurse_day = vec![vec![Vec::new(); total_days]; nurses.len()]; + for &(nurse_idx, global_day, shift_type_idx) in &shift_off_requests { + if nurse_idx < shift_off_requests_by_nurse_day.len() && global_day < total_days { + shift_off_requests_by_nurse_day[nurse_idx][global_day].push(shift_type_idx); + } + } + + let mut forbidden_successors = vec![Vec::new(); num_shift_types]; + for (preceding, succeeding) in &forbidden { + if *preceding < forbidden_successors.len() { + forbidden_successors[*preceding] = succeeding.clone(); + } + } + + let problem_data = ProblemData { + nurses, + contracts: input.contracts, + shift_types: input.shift_types, + forbidden, + forbidden_successors, + shift_off_requests, + shift_off_requests_by_nurse_day, + nurse_history, + num_weeks: input.num_weeks, + num_shift_types, + }; + let shifts: Vec = input + .shifts + .into_iter() + .enumerate() + .map(|(id, s)| { + let global_day = s.week * 7 + s.day; + let shift_type_idx = s.shift_type_idx; + let forbidden_predecessors = problem_data + .forbidden + .iter() + .filter_map(|(preceding, succeeding)| { + if succeeding.contains(&shift_type_idx) { + Some(*preceding) + } else { + None + } + }) + .collect(); + let shift_off_request_nurses = problem_data + .shift_off_requests_by_nurse_day + .iter() + .enumerate() + .flat_map(|(nurse_idx, days)| { + days.get(global_day).into_iter().flat_map(move |requests| { + requests.iter().filter_map(move |request_shift| { + (*request_shift == usize::MAX || *request_shift == shift_type_idx) + .then_some(nurse_idx) + }) + }) + }) + .collect(); + + NrpShift { + forbidden_predecessors, + shift_off_request_nurses, + id, + week: s.week, + day: s.day, + shift_type_idx, + skill_idx: s.skill_idx, + is_minimum: s.is_minimum, + nurse_idx: None, + } + }) + .collect(); + + let nurse_indices: Vec = problem_data + .nurses + .iter() + .map(|nurse| { + let contract = &problem_data.contracts[nurse.contract_idx]; + let history = &problem_data.nurse_history[nurse.index]; + + NurseIndex { + id: nurse.index, + skills: nurse.skills.clone(), + last_shift_type_idx: history.last_shift_type_idx, + history_assignments: history.num_assignments, + history_working_weekends: history.num_working_weekends, + history_consecutive_assignments: history.num_consecutive_assignments, + history_consecutive_working: history.num_consecutive_working, + history_consecutive_off: history.num_consecutive_off, + total_days: total_days as i64, + min_assignments: contract.min_assignments, + max_assignments: contract.max_assignments, + min_consecutive_working: contract.min_consecutive_working, + max_consecutive_working: contract.max_consecutive_working, + min_consecutive_off: contract.min_consecutive_off, + max_consecutive_off: contract.max_consecutive_off, + max_working_weekends: contract.max_working_weekends, + complete_weekends: contract.complete_weekends, + } + }) + .collect(); + let nurse_shift_type_indices: Vec = + problem_data + .nurses + .iter() + .flat_map(|nurse| { + let history = &problem_data.nurse_history[nurse.index]; + problem_data.shift_types.iter().enumerate().map( + move |(shift_type_idx, shift_type)| NurseShiftTypeIndex { + id: nurse.index * num_shift_types + shift_type_idx, + nurse_idx: nurse.index, + shift_type_idx, + min_consecutive: shift_type.min_consecutive, + max_consecutive: shift_type.max_consecutive, + history_last_shift_type_idx: history.last_shift_type_idx, + history_consecutive_assignments: history.num_consecutive_assignments, + total_days: total_days as i64, + }, + ) + }) + .collect(); + + let shift_nurse_candidates: Vec> = shifts + .iter() + .map(|shift| { + problem_data + .nurses + .iter() + .filter(|nurse| { + nurse.skills.contains(&shift.skill_idx) + && (shift.global_day() != 0 + || problem_data.history_allows(nurse.index, shift.shift_type_idx)) + }) + .map(|nurse| nurse.index) + .collect() + }) + .collect(); + let shift_indices: Vec = (0..shifts.len()).collect(); + + let plan = NrpPlan { + shifts, + nurse_indices, + nurse_shift_type_indices, + score: None, + shift_nurse_candidates, + shift_indices, + time_limit_secs: time_limit.max(1), + move_threads, + data: problem_data, + }; + let fair_start_witness = serde_json::json!({ + "adapter_hint_count": 0, + "preliminary_solve_count": 0, + "fallback_solution_enabled": false, + "preassigned_scalar_variables": plan.shifts.iter().filter(|shift| shift.nurse_idx.is_some()).count(), + "prefilled_list_variables": 0, + }); + + let (solved, telemetry) = solve(plan, time_limit)?; + + let missing_required_shifts: Vec<_> = solved + .shifts + .iter() + .filter(|shift| shift.is_minimum && shift.nurse_idx.is_none()) + .map(|shift| shift.id) + .collect(); + if !missing_required_shifts.is_empty() { + return Err(format!( + "SolverForge NRP returned required shifts without a nurse: {missing_required_shifts:?}" + )); + } + + let score = solved + .score + .ok_or_else(|| "SolverForge NRP produced no score".to_string())?; + let analysis = solved.analyze(); + let fresh_score = analysis.score; + let reported_cost = -score.soft(); + let fresh_cost = -fresh_score.soft(); + let constraint_breakdown: Vec<_> = analysis + .constraints + .iter() + .map(|constraint| { + serde_json::json!({ + "name": &constraint.name, + "score": constraint.score.to_string(), + "match_count": constraint.match_count, + }) + }) + .collect(); + + // Build output: assignments grouped by week + let days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]; + let mut weekly: Vec> = vec![vec![]; input.num_weeks]; + for s in &solved.shifts { + if let Some(nurse_idx) = s.nurse_idx { + let obj = serde_json::json!({ + "nurse": input.nurse_names[nurse_idx], + "day": days[s.day], + "shiftType": input.shift_type_names[s.shift_type_idx], + "skill": input.skill_names[s.skill_idx], + }); + weekly[s.week].push(obj); + } + } + + let output = serde_json::json!({ + "assignments": weekly, + "cost": fresh_cost, + "reported_cost": reported_cost, + "fresh_cost": fresh_cost, + "score_delta": reported_cost - fresh_cost, + "score_drift": score != fresh_score, + "hard_violations": -fresh_score.hard(), + "reported_score": score.to_string(), + "fresh_score": fresh_score.to_string(), + "solverforge_telemetry": telemetry.as_ref().map(|telemetry| telemetry_json(telemetry, move_threads)), + "constraint_breakdown": constraint_breakdown, + "fair_start_witness": fair_start_witness, + }); + + serde_json::to_string(&output).map_err(|e| format!("Serialization error: {}", e)) +} + +#[pyfunction] +#[pyo3(signature = (instance_json, time_limit, move_threads = 1))] +fn solve_nrp(instance_json: &str, time_limit: u64, move_threads: usize) -> PyResult { + do_solve(instance_json, time_limit, move_threads) + .map_err(pyo3::exceptions::PyValueError::new_err) +} + +#[pymodule] +fn solverforge_nrp(m: &Bound<'_, PyModule>) -> PyResult<()> { + m.add_function(wrap_pyfunction!(solve_nrp, m)?)?; + Ok(()) +} + +/// The `solverforge_telemetry` section of the output document. +fn telemetry_json(telemetry: &SolverTelemetry, move_threads: usize) -> serde_json::Value { + serde_json::json!({ + "move_threads": move_threads, + "elapsed_ms": telemetry.elapsed.as_millis(), + "moves_speculative": telemetry.moves_speculative, + "generation_time_ms": telemetry.generation_time.as_millis(), + "evaluation_time_ms": telemetry.evaluation_time.as_millis(), + "step_count": telemetry.step_count, + "moves_generated": telemetry.moves_generated, + "moves_evaluated": telemetry.moves_evaluated, + "moves_accepted": telemetry.moves_accepted, + "moves_applied": telemetry.moves_applied, + "moves_not_doable": telemetry.moves_not_doable, + "moves_acceptor_rejected": telemetry.moves_acceptor_rejected, + "moves_forager_ignored": telemetry.moves_forager_ignored, + "moves_hard_improving": telemetry.moves_hard_improving, + "moves_hard_neutral": telemetry.moves_hard_neutral, + "moves_hard_worse": telemetry.moves_hard_worse, + "score_calculations": telemetry.score_calculations, + "scalar_assignment_required_remaining": telemetry.scalar_assignment_required_remaining, + "phases": telemetry.phases.iter().map(|phase| serde_json::json!({ + "phase_type": phase.phase_type, + "elapsed_ms": phase.elapsed.as_millis(), + "step_count": phase.step_count, + "moves_evaluated": phase.moves_evaluated, + "moves_speculative": phase.moves_speculative, + "generation_time_ms": phase.generation_time.as_millis(), + "evaluation_time_ms": phase.evaluation_time.as_millis(), + })).collect::>(), + "selector_telemetry": telemetry.selector_telemetry.iter().map(|selector| serde_json::json!({ + "selector_index": selector.selector_index, + "selector_label": selector.selector_label, + "moves_generated": selector.moves_generated, + "moves_evaluated": selector.moves_evaluated, + "moves_accepted": selector.moves_accepted, + "moves_applied": selector.moves_applied, + "moves_not_doable": selector.moves_not_doable, + "moves_acceptor_rejected": selector.moves_acceptor_rejected, + "moves_forager_ignored": selector.moves_forager_ignored, + })).collect::>(), + "move_telemetry": telemetry.move_telemetry.iter().map(|mov| serde_json::json!({ + "move_label": mov.move_label, + "moves_generated": mov.moves_generated, + "moves_evaluated": mov.moves_evaluated, + "moves_accepted": mov.moves_accepted, + "moves_applied": mov.moves_applied, + "moves_not_doable": mov.moves_not_doable, + "moves_acceptor_rejected": mov.moves_acceptor_rejected, + "moves_forager_ignored": mov.moves_forager_ignored, + "moves_score_improving": mov.moves_score_improving, + "moves_score_equal": mov.moves_score_equal, + "moves_score_worse": mov.moves_score_worse, + "moves_rejected_improving": mov.moves_rejected_improving, + "applied_score_improvement": mov.applied_score_improvement, + })).collect::>(), + "applied_move_trace": telemetry.applied_move_trace.iter().map(|mov| serde_json::json!({ + "step_index": mov.step_index, + "move_label": mov.move_label, + "selected_candidate_index": mov.selected_candidate_index, + "moves_generated_this_step": mov.moves_generated_this_step, + "moves_evaluated_this_step": mov.moves_evaluated_this_step, + "moves_accepted_this_step": mov.moves_accepted_this_step, + "moves_forager_ignored_this_step": mov.moves_forager_ignored_this_step, + "score_before": mov.score_before, + "score_after": mov.score_after, + "score_delta": mov.score_delta, + "hard_feasible_before": mov.hard_feasible_before, + "hard_feasible_after": mov.hard_feasible_after, + })).collect::>(), + }) +} diff --git a/scalar-variable/employee-scheduling/src/employee_scheduling_bench/solver/solverforge_nrp/src/lib.rs b/scalar-variable/employee-scheduling/src/employee_scheduling_bench/solver/solverforge_nrp/src/lib.rs index a3ef694..fac93b2 100644 --- a/scalar-variable/employee-scheduling/src/employee_scheduling_bench/solver/solverforge_nrp/src/lib.rs +++ b/scalar-variable/employee-scheduling/src/employee_scheduling_bench/solver/solverforge_nrp/src/lib.rs @@ -1,6 +1,3 @@ -// The output document nests deeper than serde_json::json! expands by default. -#![recursion_limit = "256"] - mod constraints; solverforge::planning_model! { @@ -18,424 +15,5 @@ solverforge::planning_model! { pub use domain::ProblemData; pub use domain::ShiftTypeData; } +mod adapter; mod solver; - -use pyo3::prelude::*; -use serde::Deserialize; -use solverforge::Analyzable; - -use solver::solve; - -#[derive(Deserialize)] -struct NurseInput { - id: String, - contract_idx: usize, - skills: Vec, -} - -#[derive(Deserialize)] -struct ShiftInput { - week: usize, - day: usize, - shift_type_idx: usize, - skill_idx: usize, - is_minimum: bool, -} - -#[derive(Deserialize)] -struct ForbiddenInput { - preceding: usize, - succeeding: Vec, -} - -#[derive(Deserialize)] -struct ShiftOffInput { - nurse_idx: usize, - global_day: usize, - shift_type_idx: usize, -} - -#[derive(Deserialize)] -struct HistoryInput { - nurse_idx: usize, - num_assignments: i64, - num_working_weekends: i64, - last_shift_type_idx: Option, - num_consecutive_assignments: i64, - num_consecutive_working: i64, - num_consecutive_off: i64, -} - -#[derive(Deserialize)] -struct InstanceInput { - nurses: Vec, - contracts: Vec, - shift_types: Vec, - forbidden: Vec, - shift_off_requests: Vec, - nurse_history: Vec, - shifts: Vec, - num_weeks: usize, - skill_names: Vec, - shift_type_names: Vec, - nurse_names: Vec, -} - -fn do_solve(instance_json: &str, time_limit: u64, move_threads: usize) -> Result { - let input: InstanceInput = - serde_json::from_str(instance_json).map_err(|e| format!("Invalid JSON: {}", e))?; - - let num_shift_types = input.shift_types.len(); - let nurses: Vec = input - .nurses - .into_iter() - .enumerate() - .map(|(i, n)| NurseData { - index: i, - id: n.id, - contract_idx: n.contract_idx, - skills: n.skills, - }) - .collect(); - - let mut nurse_history_by_index: Vec> = vec![None; nurses.len()]; - for h in input.nurse_history { - if h.nurse_idx >= nurses.len() { - return Err(format!( - "Nurse history index {} is out of range", - h.nurse_idx - )); - } - nurse_history_by_index[h.nurse_idx] = Some(NurseHistoryData { - nurse_idx: h.nurse_idx, - num_assignments: h.num_assignments, - num_working_weekends: h.num_working_weekends, - last_shift_type_idx: h.last_shift_type_idx, - num_consecutive_assignments: h.num_consecutive_assignments, - num_consecutive_working: h.num_consecutive_working, - num_consecutive_off: h.num_consecutive_off, - }); - } - let nurse_history: Vec = nurse_history_by_index - .into_iter() - .enumerate() - .map(|(nurse_idx, history)| { - history.ok_or_else(|| format!("Missing history for nurse index {}", nurse_idx)) - }) - .collect::>()?; - - let forbidden: Vec<(usize, Vec)> = input - .forbidden - .into_iter() - .map(|f| (f.preceding, f.succeeding)) - .collect(); - - let shift_off_requests: Vec<(usize, usize, usize)> = input - .shift_off_requests - .into_iter() - .map(|s| (s.nurse_idx, s.global_day, s.shift_type_idx)) - .collect(); - let total_days = input.num_weeks * 7; - let mut shift_off_requests_by_nurse_day = vec![vec![Vec::new(); total_days]; nurses.len()]; - for &(nurse_idx, global_day, shift_type_idx) in &shift_off_requests { - if nurse_idx < shift_off_requests_by_nurse_day.len() && global_day < total_days { - shift_off_requests_by_nurse_day[nurse_idx][global_day].push(shift_type_idx); - } - } - - let mut forbidden_successors = vec![Vec::new(); num_shift_types]; - for (preceding, succeeding) in &forbidden { - if *preceding < forbidden_successors.len() { - forbidden_successors[*preceding] = succeeding.clone(); - } - } - - let problem_data = ProblemData { - nurses, - contracts: input.contracts, - shift_types: input.shift_types, - forbidden, - forbidden_successors, - shift_off_requests, - shift_off_requests_by_nurse_day, - nurse_history, - num_weeks: input.num_weeks, - num_shift_types, - }; - let shifts: Vec = input - .shifts - .into_iter() - .enumerate() - .map(|(id, s)| { - let global_day = s.week * 7 + s.day; - let shift_type_idx = s.shift_type_idx; - let forbidden_predecessors = problem_data - .forbidden - .iter() - .filter_map(|(preceding, succeeding)| { - if succeeding.contains(&shift_type_idx) { - Some(*preceding) - } else { - None - } - }) - .collect(); - let shift_off_request_nurses = problem_data - .shift_off_requests_by_nurse_day - .iter() - .enumerate() - .flat_map(|(nurse_idx, days)| { - days.get(global_day).into_iter().flat_map(move |requests| { - requests.iter().filter_map(move |request_shift| { - (*request_shift == usize::MAX || *request_shift == shift_type_idx) - .then_some(nurse_idx) - }) - }) - }) - .collect(); - - NrpShift { - forbidden_predecessors, - shift_off_request_nurses, - id, - week: s.week, - day: s.day, - shift_type_idx, - skill_idx: s.skill_idx, - is_minimum: s.is_minimum, - nurse_idx: None, - } - }) - .collect(); - - let nurse_indices: Vec = problem_data - .nurses - .iter() - .map(|nurse| { - let contract = &problem_data.contracts[nurse.contract_idx]; - let history = &problem_data.nurse_history[nurse.index]; - - NurseIndex { - id: nurse.index, - skills: nurse.skills.clone(), - last_shift_type_idx: history.last_shift_type_idx, - history_assignments: history.num_assignments, - history_working_weekends: history.num_working_weekends, - history_consecutive_assignments: history.num_consecutive_assignments, - history_consecutive_working: history.num_consecutive_working, - history_consecutive_off: history.num_consecutive_off, - total_days: total_days as i64, - min_assignments: contract.min_assignments, - max_assignments: contract.max_assignments, - min_consecutive_working: contract.min_consecutive_working, - max_consecutive_working: contract.max_consecutive_working, - min_consecutive_off: contract.min_consecutive_off, - max_consecutive_off: contract.max_consecutive_off, - max_working_weekends: contract.max_working_weekends, - complete_weekends: contract.complete_weekends, - } - }) - .collect(); - let nurse_shift_type_indices: Vec = - problem_data - .nurses - .iter() - .flat_map(|nurse| { - let history = &problem_data.nurse_history[nurse.index]; - problem_data.shift_types.iter().enumerate().map( - move |(shift_type_idx, shift_type)| NurseShiftTypeIndex { - id: nurse.index * num_shift_types + shift_type_idx, - nurse_idx: nurse.index, - shift_type_idx, - min_consecutive: shift_type.min_consecutive, - max_consecutive: shift_type.max_consecutive, - history_last_shift_type_idx: history.last_shift_type_idx, - history_consecutive_assignments: history.num_consecutive_assignments, - total_days: total_days as i64, - }, - ) - }) - .collect(); - - let shift_nurse_candidates: Vec> = shifts - .iter() - .map(|shift| { - problem_data - .nurses - .iter() - .filter(|nurse| { - nurse.skills.contains(&shift.skill_idx) - && (shift.global_day() != 0 - || problem_data.history_allows(nurse.index, shift.shift_type_idx)) - }) - .map(|nurse| nurse.index) - .collect() - }) - .collect(); - let shift_indices: Vec = (0..shifts.len()).collect(); - - let plan = NrpPlan { - shifts, - nurse_indices, - nurse_shift_type_indices, - score: None, - shift_nurse_candidates, - shift_indices, - time_limit_secs: time_limit.max(1), - move_threads, - data: problem_data, - }; - let fair_start_witness = serde_json::json!({ - "adapter_hint_count": 0, - "preliminary_solve_count": 0, - "fallback_solution_enabled": false, - "preassigned_scalar_variables": plan.shifts.iter().filter(|shift| shift.nurse_idx.is_some()).count(), - "prefilled_list_variables": 0, - }); - - let (solved, telemetry) = solve(plan, time_limit)?; - - let missing_required_shifts: Vec<_> = solved - .shifts - .iter() - .filter(|shift| shift.is_minimum && shift.nurse_idx.is_none()) - .map(|shift| shift.id) - .collect(); - if !missing_required_shifts.is_empty() { - return Err(format!( - "SolverForge NRP returned required shifts without a nurse: {missing_required_shifts:?}" - )); - } - - let score = solved - .score - .ok_or_else(|| "SolverForge NRP produced no score".to_string())?; - let analysis = solved.analyze(); - let fresh_score = analysis.score; - let reported_cost = -score.soft(); - let fresh_cost = -fresh_score.soft(); - let constraint_breakdown: Vec<_> = analysis - .constraints - .iter() - .map(|constraint| { - serde_json::json!({ - "name": &constraint.name, - "score": constraint.score.to_string(), - "match_count": constraint.match_count, - }) - }) - .collect(); - - // Build output: assignments grouped by week - let days = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]; - let mut weekly: Vec> = vec![vec![]; input.num_weeks]; - for s in &solved.shifts { - if let Some(nurse_idx) = s.nurse_idx { - let obj = serde_json::json!({ - "nurse": input.nurse_names[nurse_idx], - "day": days[s.day], - "shiftType": input.shift_type_names[s.shift_type_idx], - "skill": input.skill_names[s.skill_idx], - }); - weekly[s.week].push(obj); - } - } - - let output = serde_json::json!({ - "assignments": weekly, - "cost": fresh_cost, - "reported_cost": reported_cost, - "fresh_cost": fresh_cost, - "score_delta": reported_cost - fresh_cost, - "score_drift": score != fresh_score, - "hard_violations": -fresh_score.hard(), - "reported_score": score.to_string(), - "fresh_score": fresh_score.to_string(), - "solverforge_telemetry": telemetry.as_ref().map(|telemetry| serde_json::json!({ - "move_threads": move_threads, - "elapsed_ms": telemetry.elapsed.as_millis(), - "moves_speculative": telemetry.moves_speculative, - "generation_time_ms": telemetry.generation_time.as_millis(), - "evaluation_time_ms": telemetry.evaluation_time.as_millis(), - "step_count": telemetry.step_count, - "moves_generated": telemetry.moves_generated, - "moves_evaluated": telemetry.moves_evaluated, - "moves_accepted": telemetry.moves_accepted, - "moves_applied": telemetry.moves_applied, - "moves_not_doable": telemetry.moves_not_doable, - "moves_acceptor_rejected": telemetry.moves_acceptor_rejected, - "moves_forager_ignored": telemetry.moves_forager_ignored, - "moves_hard_improving": telemetry.moves_hard_improving, - "moves_hard_neutral": telemetry.moves_hard_neutral, - "moves_hard_worse": telemetry.moves_hard_worse, - "score_calculations": telemetry.score_calculations, - "scalar_assignment_required_remaining": telemetry.scalar_assignment_required_remaining, - "phases": telemetry.phases.iter().map(|phase| serde_json::json!({ - "phase_type": phase.phase_type, - "elapsed_ms": phase.elapsed.as_millis(), - "step_count": phase.step_count, - "moves_evaluated": phase.moves_evaluated, - "moves_speculative": phase.moves_speculative, - "generation_time_ms": phase.generation_time.as_millis(), - "evaluation_time_ms": phase.evaluation_time.as_millis(), - })).collect::>(), - "selector_telemetry": telemetry.selector_telemetry.iter().map(|selector| serde_json::json!({ - "selector_index": selector.selector_index, - "selector_label": selector.selector_label, - "moves_generated": selector.moves_generated, - "moves_evaluated": selector.moves_evaluated, - "moves_accepted": selector.moves_accepted, - "moves_applied": selector.moves_applied, - "moves_not_doable": selector.moves_not_doable, - "moves_acceptor_rejected": selector.moves_acceptor_rejected, - "moves_forager_ignored": selector.moves_forager_ignored, - })).collect::>(), - "move_telemetry": telemetry.move_telemetry.iter().map(|mov| serde_json::json!({ - "move_label": mov.move_label, - "moves_generated": mov.moves_generated, - "moves_evaluated": mov.moves_evaluated, - "moves_accepted": mov.moves_accepted, - "moves_applied": mov.moves_applied, - "moves_not_doable": mov.moves_not_doable, - "moves_acceptor_rejected": mov.moves_acceptor_rejected, - "moves_forager_ignored": mov.moves_forager_ignored, - "moves_score_improving": mov.moves_score_improving, - "moves_score_equal": mov.moves_score_equal, - "moves_score_worse": mov.moves_score_worse, - "moves_rejected_improving": mov.moves_rejected_improving, - "applied_score_improvement": mov.applied_score_improvement, - })).collect::>(), - "applied_move_trace": telemetry.applied_move_trace.iter().map(|mov| serde_json::json!({ - "step_index": mov.step_index, - "move_label": mov.move_label, - "selected_candidate_index": mov.selected_candidate_index, - "moves_generated_this_step": mov.moves_generated_this_step, - "moves_evaluated_this_step": mov.moves_evaluated_this_step, - "moves_accepted_this_step": mov.moves_accepted_this_step, - "moves_forager_ignored_this_step": mov.moves_forager_ignored_this_step, - "score_before": mov.score_before, - "score_after": mov.score_after, - "score_delta": mov.score_delta, - "hard_feasible_before": mov.hard_feasible_before, - "hard_feasible_after": mov.hard_feasible_after, - })).collect::>(), - })), - "constraint_breakdown": constraint_breakdown, - "fair_start_witness": fair_start_witness, - }); - - serde_json::to_string(&output).map_err(|e| format!("Serialization error: {}", e)) -} - -#[pyfunction] -#[pyo3(signature = (instance_json, time_limit, move_threads = 1))] -fn solve_nrp(instance_json: &str, time_limit: u64, move_threads: usize) -> PyResult { - do_solve(instance_json, time_limit, move_threads) - .map_err(pyo3::exceptions::PyValueError::new_err) -} - -#[pymodule] -fn solverforge_nrp(m: &Bound<'_, PyModule>) -> PyResult<()> { - m.add_function(wrap_pyfunction!(solve_nrp, m)?)?; - Ok(()) -} diff --git a/scalar-variable/job-shop-scheduling/src/job_shop_bench/solver/solverforge_jssp/src/adapter.rs b/scalar-variable/job-shop-scheduling/src/job_shop_bench/solver/solverforge_jssp/src/adapter.rs new file mode 100644 index 0000000..3c85b4d --- /dev/null +++ b/scalar-variable/job-shop-scheduling/src/job_shop_bench/solver/solverforge_jssp/src/adapter.rs @@ -0,0 +1,258 @@ +//! PyO3 entry point for the job-shop benchmark: reads an instance as JSON, +//! solves it with SolverForge, and returns the schedule and fair-start witness. + +use crate::{JsspOperation, JsspPlan, MachineSequence}; +use pyo3::prelude::*; +use serde::{Deserialize, Serialize}; +use solverforge::{SolverEvent, SolverManager}; + +static MANAGER: SolverManager = SolverManager::new(); + +#[derive(Deserialize)] +struct OperationInput { + job_id: usize, + op_index: usize, + machine_id: usize, + duration: usize, +} + +#[derive(Deserialize)] +struct InstanceInput { + num_jobs: usize, + num_machines: usize, + operations: Vec, +} + +#[derive(Serialize)] +struct OperationOutput { + job_id: usize, + op_index: usize, + machine_id: usize, + start: usize, + duration: usize, +} + +#[derive(Serialize)] +struct SolutionOutput { + operations: Vec, + reported_makespan: usize, + fair_start_witness: FairStartWitness, +} + +#[derive(Serialize)] +struct FairStartWitness { + adapter_hint_count: usize, + preliminary_solve_count: usize, + fallback_solution_enabled: bool, + preassigned_scalar_variables: usize, + prefilled_list_variables: usize, +} + +fn build_plan(input: InstanceInput, time_limit_secs: u64) -> JsspPlan { + let mut operations: Vec<_> = input + .operations + .into_iter() + .enumerate() + .map(|(id, operation)| JsspOperation { + id, + job_id: operation.job_id, + op_index: operation.op_index, + machine_id: operation.machine_id, + duration: operation.duration, + successor_id: None, + }) + .collect(); + let index_by_job_op = operations + .iter() + .map(|operation| ((operation.job_id, operation.op_index), operation.id)) + .collect::>(); + for operation in &mut operations { + operation.successor_id = index_by_job_op + .get(&(operation.job_id, operation.op_index + 1)) + .copied(); + } + let machine_sequences = (0..input.num_machines) + .map(|id| MachineSequence { + id, + operations: Vec::new(), + }) + .collect(); + + JsspPlan { + operations, + machine_sequences, + score: None, + num_jobs: input.num_jobs, + num_machines: input.num_machines, + time_limit_secs, + } +} + +fn solve_plan(plan: JsspPlan) -> Result { + let (job_id, mut receiver) = MANAGER + .solve(plan) + .map_err(|error| format!("SolverForge manager rejected JSSP job: {error}"))?; + let mut completed = None; + let mut failure = None; + + while let Some(event) = receiver.blocking_recv() { + match event { + SolverEvent::BestSolution { .. } => {} + SolverEvent::Completed { solution, .. } => { + completed = Some(solution); + break; + } + SolverEvent::Cancelled { .. } => { + failure = Some("SolverForge JSSP job was cancelled".to_string()); + break; + } + SolverEvent::Failed { error, .. } => { + failure = Some(format!("SolverForge JSSP job failed: {error}")); + break; + } + SolverEvent::Progress { .. } + | SolverEvent::PauseRequested { .. } + | SolverEvent::Paused { .. } + | SolverEvent::Resumed { .. } => {} + } + } + let _ = MANAGER.delete(job_id); + if let Some(error) = failure { + return Err(error); + } + completed.ok_or_else(|| "SolverForge JSSP event stream closed before completion".to_string()) +} + +fn solution_output( + plan: JsspPlan, + fair_start_witness: FairStartWitness, +) -> Result { + let evaluation = plan.evaluate_schedule(); + if evaluation.hard_penalty > 0 { + return Err(format!( + "SolverForge JSSP returned an incomplete or invalid schedule (hard penalty: {})", + evaluation.hard_penalty + )); + } + let mut operations: Vec = plan + .operations + .iter() + .map(|operation| -> Result { + let start = evaluation + .starts + .get(operation.id) + .and_then(|start| *start) + .ok_or_else(|| { + format!( + "SolverForge JSSP did not compute a start for operation {}", + operation.id + ) + })?; + Ok(OperationOutput { + job_id: operation.job_id, + op_index: operation.op_index, + machine_id: operation.machine_id, + start, + duration: operation.duration, + }) + }) + .collect::>()?; + operations.sort_by_key(|operation| (operation.job_id, operation.op_index)); + Ok(SolutionOutput { + operations, + reported_makespan: evaluation.makespan, + fair_start_witness, + }) +} + +#[pyfunction] +fn solve_jssp(instance_json: &str, time_limit: u64) -> PyResult { + let input: InstanceInput = serde_json::from_str(instance_json) + .map_err(|error| pyo3::exceptions::PyValueError::new_err(error.to_string()))?; + let plan = build_plan(input, time_limit); + let fair_start_witness = FairStartWitness { + adapter_hint_count: 0, + preliminary_solve_count: 0, + fallback_solution_enabled: false, + preassigned_scalar_variables: 0, + prefilled_list_variables: plan + .machine_sequences + .iter() + .filter(|machine| !machine.operations.is_empty()) + .count(), + }; + let solved = solve_plan(plan).map_err(pyo3::exceptions::PyRuntimeError::new_err)?; + let output = solution_output(solved, fair_start_witness) + .map_err(pyo3::exceptions::PyRuntimeError::new_err)?; + serde_json::to_string(&output) + .map_err(|error| pyo3::exceptions::PyValueError::new_err(error.to_string())) +} + +#[pymodule] +fn solverforge_jssp(m: &Bound<'_, PyModule>) -> PyResult<()> { + m.add_function(wrap_pyfunction!(solve_jssp, m)?)?; + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn plan(machine_operations: [Vec; 2]) -> JsspPlan { + JsspPlan { + operations: vec![ + JsspOperation { + id: 0, + job_id: 0, + op_index: 0, + machine_id: 0, + duration: 3, + successor_id: Some(1), + }, + JsspOperation { + id: 1, + job_id: 0, + op_index: 1, + machine_id: 1, + duration: 2, + successor_id: None, + }, + ], + machine_sequences: machine_operations + .into_iter() + .enumerate() + .map(|(id, operations)| MachineSequence { id, operations }) + .collect(), + score: None, + num_jobs: 1, + num_machines: 2, + time_limit_secs: 1, + } + } + + fn witness() -> FairStartWitness { + FairStartWitness { + adapter_hint_count: 0, + preliminary_solve_count: 0, + fallback_solution_enabled: false, + preassigned_scalar_variables: 0, + prefilled_list_variables: 0, + } + } + + #[test] + fn solution_output_accepts_complete_schedule() { + let output = solution_output(plan([vec![0], vec![1]]), witness()) + .expect("complete schedule should serialize"); + + assert_eq!(output.operations.len(), 2); + assert_eq!(output.reported_makespan, 5); + } + + #[test] + fn solution_output_rejects_missing_operation() { + let result = solution_output(plan([vec![0], vec![]]), witness()); + + assert!(matches!(result, Err(error) if error.contains("hard penalty"))); + } +} diff --git a/scalar-variable/job-shop-scheduling/src/job_shop_bench/solver/solverforge_jssp/src/lib.rs b/scalar-variable/job-shop-scheduling/src/job_shop_bench/solver/solverforge_jssp/src/lib.rs index 2f03d57..02149b6 100644 --- a/scalar-variable/job-shop-scheduling/src/job_shop_bench/solver/solverforge_jssp/src/lib.rs +++ b/scalar-variable/job-shop-scheduling/src/job_shop_bench/solver/solverforge_jssp/src/lib.rs @@ -9,258 +9,4 @@ solverforge::planning_model! { pub use domain::JsspPlan; pub use domain::MachineSequence; } - -use pyo3::prelude::*; -use serde::{Deserialize, Serialize}; -use solverforge::{SolverEvent, SolverManager}; - -static MANAGER: SolverManager = SolverManager::new(); - -#[derive(Deserialize)] -struct OperationInput { - job_id: usize, - op_index: usize, - machine_id: usize, - duration: usize, -} - -#[derive(Deserialize)] -struct InstanceInput { - num_jobs: usize, - num_machines: usize, - operations: Vec, -} - -#[derive(Serialize)] -struct OperationOutput { - job_id: usize, - op_index: usize, - machine_id: usize, - start: usize, - duration: usize, -} - -#[derive(Serialize)] -struct SolutionOutput { - operations: Vec, - reported_makespan: usize, - fair_start_witness: FairStartWitness, -} - -#[derive(Serialize)] -struct FairStartWitness { - adapter_hint_count: usize, - preliminary_solve_count: usize, - fallback_solution_enabled: bool, - preassigned_scalar_variables: usize, - prefilled_list_variables: usize, -} - -fn build_plan(input: InstanceInput, time_limit_secs: u64) -> JsspPlan { - let mut operations: Vec<_> = input - .operations - .into_iter() - .enumerate() - .map(|(id, operation)| JsspOperation { - id, - job_id: operation.job_id, - op_index: operation.op_index, - machine_id: operation.machine_id, - duration: operation.duration, - successor_id: None, - }) - .collect(); - let index_by_job_op = operations - .iter() - .map(|operation| ((operation.job_id, operation.op_index), operation.id)) - .collect::>(); - for operation in &mut operations { - operation.successor_id = index_by_job_op - .get(&(operation.job_id, operation.op_index + 1)) - .copied(); - } - let machine_sequences = (0..input.num_machines) - .map(|id| MachineSequence { - id, - operations: Vec::new(), - }) - .collect(); - - JsspPlan { - operations, - machine_sequences, - score: None, - num_jobs: input.num_jobs, - num_machines: input.num_machines, - time_limit_secs, - } -} - -fn solve_plan(plan: JsspPlan) -> Result { - let (job_id, mut receiver) = MANAGER - .solve(plan) - .map_err(|error| format!("SolverForge manager rejected JSSP job: {error}"))?; - let mut completed = None; - let mut failure = None; - - while let Some(event) = receiver.blocking_recv() { - match event { - SolverEvent::BestSolution { .. } => {} - SolverEvent::Completed { solution, .. } => { - completed = Some(solution); - break; - } - SolverEvent::Cancelled { .. } => { - failure = Some("SolverForge JSSP job was cancelled".to_string()); - break; - } - SolverEvent::Failed { error, .. } => { - failure = Some(format!("SolverForge JSSP job failed: {error}")); - break; - } - SolverEvent::Progress { .. } - | SolverEvent::PauseRequested { .. } - | SolverEvent::Paused { .. } - | SolverEvent::Resumed { .. } => {} - } - } - let _ = MANAGER.delete(job_id); - if let Some(error) = failure { - return Err(error); - } - completed.ok_or_else(|| "SolverForge JSSP event stream closed before completion".to_string()) -} - -fn solution_output( - plan: JsspPlan, - fair_start_witness: FairStartWitness, -) -> Result { - let evaluation = plan.evaluate_schedule(); - if evaluation.hard_penalty > 0 { - return Err(format!( - "SolverForge JSSP returned an incomplete or invalid schedule (hard penalty: {})", - evaluation.hard_penalty - )); - } - let mut operations: Vec = plan - .operations - .iter() - .map(|operation| -> Result { - let start = evaluation - .starts - .get(operation.id) - .and_then(|start| *start) - .ok_or_else(|| { - format!( - "SolverForge JSSP did not compute a start for operation {}", - operation.id - ) - })?; - Ok(OperationOutput { - job_id: operation.job_id, - op_index: operation.op_index, - machine_id: operation.machine_id, - start, - duration: operation.duration, - }) - }) - .collect::>()?; - operations.sort_by_key(|operation| (operation.job_id, operation.op_index)); - Ok(SolutionOutput { - operations, - reported_makespan: evaluation.makespan, - fair_start_witness, - }) -} - -#[pyfunction] -fn solve_jssp(instance_json: &str, time_limit: u64) -> PyResult { - let input: InstanceInput = serde_json::from_str(instance_json) - .map_err(|error| pyo3::exceptions::PyValueError::new_err(error.to_string()))?; - let plan = build_plan(input, time_limit); - let fair_start_witness = FairStartWitness { - adapter_hint_count: 0, - preliminary_solve_count: 0, - fallback_solution_enabled: false, - preassigned_scalar_variables: 0, - prefilled_list_variables: plan - .machine_sequences - .iter() - .filter(|machine| !machine.operations.is_empty()) - .count(), - }; - let solved = solve_plan(plan).map_err(pyo3::exceptions::PyRuntimeError::new_err)?; - let output = solution_output(solved, fair_start_witness) - .map_err(pyo3::exceptions::PyRuntimeError::new_err)?; - serde_json::to_string(&output) - .map_err(|error| pyo3::exceptions::PyValueError::new_err(error.to_string())) -} - -#[pymodule] -fn solverforge_jssp(m: &Bound<'_, PyModule>) -> PyResult<()> { - m.add_function(wrap_pyfunction!(solve_jssp, m)?)?; - Ok(()) -} - -#[cfg(test)] -mod tests { - use super::*; - - fn plan(machine_operations: [Vec; 2]) -> JsspPlan { - JsspPlan { - operations: vec![ - JsspOperation { - id: 0, - job_id: 0, - op_index: 0, - machine_id: 0, - duration: 3, - successor_id: Some(1), - }, - JsspOperation { - id: 1, - job_id: 0, - op_index: 1, - machine_id: 1, - duration: 2, - successor_id: None, - }, - ], - machine_sequences: machine_operations - .into_iter() - .enumerate() - .map(|(id, operations)| MachineSequence { id, operations }) - .collect(), - score: None, - num_jobs: 1, - num_machines: 2, - time_limit_secs: 1, - } - } - - fn witness() -> FairStartWitness { - FairStartWitness { - adapter_hint_count: 0, - preliminary_solve_count: 0, - fallback_solution_enabled: false, - preassigned_scalar_variables: 0, - prefilled_list_variables: 0, - } - } - - #[test] - fn solution_output_accepts_complete_schedule() { - let output = solution_output(plan([vec![0], vec![1]]), witness()) - .expect("complete schedule should serialize"); - - assert_eq!(output.operations.len(), 2); - assert_eq!(output.reported_makespan, 5); - } - - #[test] - fn solution_output_rejects_missing_operation() { - let result = solution_output(plan([vec![0], vec![]]), witness()); - - assert!(matches!(result, Err(error) if error.contains("hard penalty"))); - } -} +mod adapter; diff --git a/scripts/verify_fair_start.py b/scripts/verify_fair_start.py index 674c775..b247d9f 100644 --- a/scripts/verify_fair_start.py +++ b/scripts/verify_fair_start.py @@ -178,7 +178,7 @@ def check_positive_start_shapes() -> list[Violation]: violations.extend( require_contains( REPO_ROOT - / "list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/lib.rs", + / "list-variable/cvrp/src/cvrp_bench/solver/solverforge/src/adapter.rs", "visits: Vec::new()", "CVRP SolverForge routes must start empty", ) @@ -194,7 +194,7 @@ def check_positive_start_shapes() -> list[Violation]: violations.extend( require_contains( REPO_ROOT - / "scalar-variable/employee-scheduling/src/employee_scheduling_bench/solver/solverforge_nrp/src/lib.rs", + / "scalar-variable/employee-scheduling/src/employee_scheduling_bench/solver/solverforge_nrp/src/adapter.rs", "nurse_idx: None", "employee SolverForge shifts must start unassigned", ) @@ -211,7 +211,7 @@ def check_positive_start_shapes() -> list[Violation]: violations.extend( require_contains( REPO_ROOT - / "scalar-variable/job-shop-scheduling/src/job_shop_bench/solver/solverforge_jssp/src/lib.rs", + / "scalar-variable/job-shop-scheduling/src/job_shop_bench/solver/solverforge_jssp/src/adapter.rs", "operations: Vec::new()", "JSSP SolverForge machine sequences must start empty", )