RsBundle  Changes On Branch garbage

    /// Number of function evaluation.
    cnt_evals: usize,

    /// Time when the solution process started.
    ///
    /// This is actually the time of the last call to `Solver::init`.
    start_time: Instant,

    /// Time when the last master problem evaluation started.
    start_master_time: Instant,

    /// Time when the last subproblem evaluation started.
    start_eval_time: Instant,
}

impl<P, T, W, M> Solver<P, T, W, M>
where
    P: FirstOrderProblem,
    T: Terminator<SolverData> + Default,
    W: Weighter<SolverData> + Default,

            client_rx: None,

            cnt_descent: 0,
            cnt_null: 0,
            cnt_evals: 0,

            start_time: Instant::now(),
            start_master_time: Instant::now(),
            start_eval_time: Instant::now(),
        }
    }

    /// Return the underlying threadpool.
    ///
    /// In order to use the same threadpool for concurrent processes,
    /// just clone the returned `ThreadPool`.

    pub fn solve_iter(&mut self, niter: usize) -> Result<bool, P, M> {
        debug!("Start solving up to {} iterations", niter);

        if let Some(ref mut master_proc) = self.master_proc {
            // Continue the solution process, start with a new master
            // problem evaluation.
            if !self.data.cur_val.is_infinite() {
                self.start_master_time = Instant::now();
                master_proc.solve(self.data.cur_val)?;
            }
        } else {
            // No master problem, initialize solver.
            self.init()?;
        }

        self.reset_iteration_data(niter);

        loop {
            let msg = self.client_rx.as_ref().ok_or(Error::NotInitialized)?.recv()?;
            match msg {
                Message::Eval(m) => {
                    if self.handle_client_response(m)? {
                        return Ok(false);
                    }
                }
                Message::Update(_) => warn!("Ignore unexpected problem update message from client"),
                Message::Master(mresponse) => {
                    debug!(
                    debug!("Receive master response");
                        "Receive master response (time: {})",
                        self.start_master_time.elapsed().as_millis() as f64 / 1000.0
                    );
                    // Receive result (new candidate) from the master
                    if self.handle_master_response(mresponse)? {
                        return Ok(true);
                    }
                }
            }
        }

        // All subproblems have been evaluated, do a step.
        let nxt_ub = self.data.nxt_ubs.iter().sum::<Real>();
        let descent_bnd = Self::get_descent_bound(self.params.acceptance_factor, &self.data);

        self.data.nxt_val = nxt_ub;
        self.data.new_cutval = self.data.nxt_cutvals.iter().sum::<Real>();

        debug!("Step");
        debug!(
            "Step (time: {)",
            self.start_eval_time.elapsed().as_millis() as f64 / 1000.0
        );
        debug!("  cur_val    ={}", self.data.cur_val);
        debug!("  nxt_mod    ={}", self.data.nxt_mod);
        debug!("  nxt_ub     ={}", nxt_ub);
        debug!("  descent_bnd={}", descent_bnd);

        self.data.updated = false;
        let step;

        if self.update_problem(step)? {
            self.data.updated = true;
        }

        if self.data.cnt_iter < self.data.max_iter {
            // Compute the new candidate. The main loop will wait for the result of
            // this solution process of the master problem.
            self.start_master_time = Instant::now();
            self.master_proc.as_mut().unwrap().solve(self.data.cur_val)?;
            Ok(false)
        } else {
            Ok(true)
        }
    }

        self.data
            .nxt_cutvals
            .resize(self.problem.num_subproblems(), -Real::infinity());
        self.data.cnt_remaining_mins = self.problem.num_subproblems();

        // Start evaluation of all subproblems at the new candidate.
        let client_tx = self.client_tx.as_ref().ok_or(Error::NotInitialized)?;
        self.start_eval_time = Instant::now();
        for i in 0..self.problem.num_subproblems() {
            self.problem
                .evaluate(
                    i,
                    self.data.nxt_y.clone(),
                    ChannelResultSender::new(i, client_tx.clone()),
                )