fn solve_data_series()

in resctl-bench/src/bench/iocost_tune.rs [1541:1607]

• 61 lines of code
• 6 McCabe index (conditional complexity)

    fn solve_data_series(
        &self,
        sel: &DataSel,
        series: &mut DataSeries,
        isol_series: Option<&DataSeries>,
        isol_thr: f64,
    ) -> Result<()> {
        let (dir, filter_outliers, filter_by_isol) = sel.fit_lines_opts();
        trace!(
            "fitting {:?} points={} dir={:?} filter_outliers={} filter_by_isol={}",
            &sel,
            series.points.len(),
            &dir,
            filter_outliers,
            filter_by_isol
        );

        let mut fill_upto = None;
        if filter_by_isol {
            let dl = &isol_series
                .expect(&format!(
                    "iocost-tune: Solving {:?} requires {:?} which isn't available",
                    &sel,
                    &DataSel::Isol
                ))
                .lines;
            let slope = dl.slope();
            if slope != 0.0 && dl.right.y < isol_thr {
                let intcp =
                    (dl.right.x - (dl.right.y - isol_thr) / slope).clamp(dl.range.0, dl.range.1);
                series.filter_beyond(intcp);
                fill_upto = Some(intcp);
            }
        }

        series.fit_lines(self.gran, dir)?;

        if let Some(fill_upto) = fill_upto {
            series.fill_vrate_range((series.lines.range.0, fill_upto));
        }

        if filter_outliers {
            series.filter_outliers();
            trace!(
                "fitting {:?} points={} outliers={} dir={:?}",
                &sel,
                series.points.len(),
                series.outliers.len(),
                &dir
            );
            let range = series.lines.range;
            series.fit_lines(self.gran, dir)?;
            series.fill_vrate_range(range);
        }

        // For some data series, we fit the lines excluding the outliers
        // so that the fitted lines can be used to guess the likely
        // behaviors most of the time but we want to include the
        // outliers when reporting error so that the users can gauge the
        // flakiness of the device.
        series.error = DataSeries::calc_error(
            series.points.iter().chain(series.outliers.iter()),
            &series.lines,
        );

        Ok(())
    }