RsBundle  Diff

use threadpool::ThreadPool;

use crate::{DVector, Minorant, Real};

use super::channels::{
    ChannelResultSender, ChannelUpdateSender, ClientReceiver, ClientSender, EvalResult, Message, Update,
};
use super::masterprocess::{MasterConfig, MasterError, MasterProcess, MasterResponse, Response};
use super::masterprocess::{MasterError, MasterProcess, MasterResponse, Response};
use crate::master::{Builder as MasterBuilder, MasterProblem};
use crate::problem::{FirstOrderProblem, UpdateState};
use crate::terminator::{StandardTerminatable, StandardTerminator, Terminator};
use crate::weighter::{HKWeightable, HKWeighter, Weighter};

/// The default iteration limit.
pub const DEFAULT_ITERATION_LIMIT: usize = 10_000;

        self.cnt_null = 0;
        self.cnt_evals = 0;

        let (tx, rx) = channel();
        self.client_tx = Some(tx.clone());
        self.client_rx = Some(rx);

        let lower_bounds = self.problem.lower_bounds().map(DVector);
        if lower_bounds.as_ref().map(|lb| lb.len() != n).unwrap_or(false) {
            return Err(Error::Dimension {
                what: "lower bounds".to_string(),
            });
        }
        let master_config = self.build_master_config()?;


        let upper_bounds = self.problem.upper_bounds().map(DVector);
        if upper_bounds.as_ref().map(|ub| ub.len() != n).unwrap_or(false) {
            return Err(Error::Dimension {
                what: "upper bounds".to_string(),
            });
        }

        debug!("Start master process");
        self.master_proc = Some(MasterProcess::start(
            self.master.build().map_err(Error::BuildMaster)?,
            master_config,
            tx,
            &mut self.threadpool,

        // Initialize the master problem.
        let mut master = self.master.build().map_err(Error::BuildMaster)?;
        master.set_num_subproblems(m).map_err(Error::BuildMaster)?;
        master
            .set_vars(n, lower_bounds, upper_bounds)
            .map_err(Error::BuildMaster)?;

        self.master_proc = Some(MasterProcess::start(master, tx, &mut self.threadpool));
        ));

        debug!("Initial problem evaluation");
        // We need an initial evaluation of all oracles for the first center.
        let y = Arc::new(self.data.cur_y.clone());
        for i in 0..m {
            self.problem
                .evaluate(

        debug!("Initialization complete");

        self.start_time = Instant::now();

        Ok(())
    }

    fn build_master_config(&self) -> Result<MasterConfig, P, M> {
        let n = self.problem.num_variables();
        let m = self.problem.num_subproblems();

        let master_config = MasterConfig {
            num_subproblems: m,
            num_vars: n,
            lower_bounds: self.problem.lower_bounds().map(DVector),
            upper_bounds: self.problem.upper_bounds().map(DVector),
        };

        if master_config
            .lower_bounds
            .as_ref()
            .map(|lb| lb.len() != n)
            .unwrap_or(false)
        {
            return Err(Error::Dimension {
                what: "lower bounds".to_string(),
            });
        }

        if master_config
            .upper_bounds
            .as_ref()
            .map(|ub| ub.len() != n)
            .unwrap_or(false)
        {
            return Err(Error::Dimension {
                what: "upper bounds".to_string(),
            });
        }

        Ok(master_config)
    }

    fn reset_iteration_data(&mut self, max_iter: usize) {
        let num_subproblems = self.problem.num_subproblems();
        let num_variables = self.problem.num_variables();

        self.data.max_iter = max_iter;
        self.data.cnt_iter = 0;
        self.data.cnt_updates = 0;

    M: MasterBuilder<P::Minorant>,
{
    /// Initialize the solver with the given state.
    pub fn set_state(
        &mut self,
        state: SyncSolverState<<M::MasterProblem as MasterProblem<<P as FirstOrderProblem>::Minorant>>::State>,
    ) -> Result<(), P, M> {
        let master_config = self.build_master_config()?;

        self.data = state.data;
        self.cnt_descent = state.cnt_descent;
        self.cnt_null = state.cnt_null;
        self.cnt_evals = state.cnt_evals;

        let (tx, rx) = channel();
        self.client_tx = Some(tx.clone());
        self.client_rx = Some(rx);

        self.master_proc = if let Some(s) = state.master_state {
            Some(MasterProcess::start(
                self.master.build_with_state(s).map_err(Error::BuildMaster)?,
                master_config,
                tx,
                &mut self.threadpool,
            ))
        } else {
            None
        };