Struct ddo::ParallelSolver

pub struct ParallelSolver<T, C, F, DD> where
    T: Send + Sync + Hash + Eq + Clone,
    C: Send + Sync + Clone + Config<T>,
    F: Send + Sync + Frontier<T>,
    DD: MDD<T, C> + From<C>,  { /* fields omitted */ }

Implementations

impl<T, C, DD> ParallelSolver<T, C, SimpleFrontier<T>, DD> where
    T: Send + Sync + Hash + Eq + Clone,
    C: Send + Sync + Clone + Config<T>,
    DD: MDD<T, C> + From<C>, 

pub fn new(mdd: DD) -> Self

This creates a solver that will find the best solution in the problem described by the given mdd (mdd is not expanded yet). This solver will return the optimal solution from what would be an exact expansion of mdd.

All the other parameters will use their default value. + nb_threads will be the number of hardware threads + verbosity will be 0

Warning

By passing the given MDD, you are effectively only passing the type of the mdd to use while developing the restricted and relaxed representations. Each thread will instantiate its own fresh copy using a clone of the configuration you provided. However, it will not clone your mdd. The latter will be dropped as soon as the constructor ends. However, clean copies are created when maximizing the objective function.

pub fn customized(mdd: DD, verbosity: u8, nb_threads: usize) -> Self

This constructor lets you specify all the configuration parameters of the solver.

Return value

This solver will return the optimal solution from what would be an exact expansion of mdd.

Verbosity

So far, there are three levels of verbosity:

• 0 which prints nothing
• 1 which only prints the final statistics when the problem is solved
• 2 which prints progress information every 100 explored nodes.

Nb Threads

The nb_threads argument lets you customize the number of threads to spawn in order to solve the problem. We advise you to use the number of hardware threads on your machine.

Warning

By passing the given MDD, you are effectively only passing the type of the mdd to use while developing the restricted and relaxed representations. Each thread will instantiate its own fresh copy using a clone of the configuration you provided. However, it will not clone your mdd. The latter will be dropped as soon as the constructor ends. However, clean copies are created when maximizing the objective function.

impl<T, C, F, DD> ParallelSolver<T, C, F, DD> where
    T: Send + Sync + Hash + Eq + Clone,
    C: Send + Sync + Clone + Config<T>,
    F: Send + Sync + Frontier<T>,
    DD: MDD<T, C> + From<C>, 

private interface of the parallel solver

pub fn with_verbosity(self, verbosity: u8) -> Self

Sets the verbosity of the solver

pub fn with_nb_threads(self, nb_threads: usize) -> Self

Sets the number of threads used by the solver

pub fn with_frontier<FF: Frontier<T> + Send + Sync>(
    self,
    ff: FF
) -> ParallelSolver<T, C, FF, DD>

Sets the kind of frontier to use

Trait Implementations

impl<T, C, F, DD> Solver for ParallelSolver<T, C, F, DD> where
    T: Send + Sync + Hash + Eq + Clone,
    C: Send + Sync + Clone + Config<T>,
    F: Send + Sync + Frontier<T>,
    DD: MDD<T, C> + From<C>, 

pub fn maximize(&mut self) -> Completion

Applies the branch and bound algorithm proposed by Bergman et al. to solve the problem to optimality. To do so, it spawns nb_threads workers (long running threads); each of which will continually get a workload and process it until the problem is solved.

pub fn best_solution(&self) -> Option<Solution>

Returns the best solution that has been identified for this problem.

pub fn best_value(&self) -> Option<isize>

Returns the value of the best solution that has been identified for this problem.

pub fn set_primal(&mut self, value: isize, best_sol: Solution)

Sets the best known value and/or solution. This solution and value may be obtained from any other available means (LP relax for instance).