fn study_one()

in resctl-bench/src/bench/iocost_qos.rs [391:456]
59 lines of code
2 McCabe index (conditional complexity)

    fn study_one(
        &self,
        rctx: &mut RunCtx,
        recr: &IoCostQoSRecordRun,
    ) -> Result<IoCostQoSResultRun> {
        let sres: StorageResult = parse_json_value_or_dump(
            self.stor_job
                .study(rctx, serde_json::to_value(&recr.stor).unwrap())
                .context("Studying storage record")?,
        )
        .context("Parsing storage result")?;

        let pres: ProtectionResult = parse_json_value_or_dump(
            self.prot_job
                .study(rctx, serde_json::to_value(&recr.prot).unwrap())
                .context("Studying protection record")?,
        )
        .context("Parsing protection result")?;

        // These are trivial to calculate but cumbersome to access. Let's
        // cache the results.
        let (adjusted_mem_size, adjusted_mem_offload_factor, adjusted_mem_offload_delta) =
            if recr.prot.scenarios.len() > 0 {
                let trec = recr.prot.scenarios[0].as_mem_hog_tune().unwrap();
                match trec.final_size {
                    Some(final_size) => {
                        let amof = final_size as f64 / sres.mem_usage as f64;
                        (
                            Some(final_size),
                            Some(amof),
                            Some(sres.mem_offload_factor - amof),
                        )
                    }
                    None => (None, None, None),
                }
            } else {
                (None, None, None)
            };

        // Study the vrate and IO latency distributions across all the runs.
        let mut study_vrate = StudyMeanPcts::new(|arg| vec![arg.rep.iocost.vrate], None);
        let mut study_read_lat_pcts = StudyIoLatPcts::new("read", None);
        let mut study_write_lat_pcts = StudyIoLatPcts::new("write", None);
        let nr_reports = Studies::new()
            .add(&mut study_vrate)
            .add_multiple(&mut study_read_lat_pcts.studies())
            .add_multiple(&mut study_write_lat_pcts.studies())
            .run(rctx, recr.period)?;

        let vrate = study_vrate.result(Some(&Self::VRATE_PCTS));
        let iolat = [
            study_read_lat_pcts.result(None),
            study_write_lat_pcts.result(None),
        ];

        Ok(IoCostQoSResultRun {
            stor: sres,
            prot: pres,
            adjusted_mem_size,
            adjusted_mem_offload_factor,
            adjusted_mem_offload_delta,
            vrate,
            iolat,
            nr_reports,
        })
    }