fn get_values()

in src/data/perf_stat.rs [436:480]

• 44 lines of code
• 3 McCabe index (conditional complexity)

fn get_values(values: Vec<PerfStat>, key: String, metrics: &mut DataMetrics) -> Result<String> {
    let time_zero = &values[0].perf_stats[0].named_stats[0].time;
    let mut metadata = GraphMetadata::new();
    let mut end_values = Vec::new();
    let mut aggregate_value: f64;
    let mut metric = Metric::new(key.clone());
    for value in &values {
        let mut end_stats = EndStats::new();
        let mut end_cpu_stats = Vec::new();
        let stats = get_named_stat_for_all_cpus(value.clone(), key.clone());
        let mut aggregate_nr = 0;
        let mut aggregate_dr = 0;
        for stat in &stats {
            let this_cpu_end_stat_value =
                stat.named_stat.nr_value as f64 / stat.named_stat.dr_value as f64;
            let this_cpu_end_stat = EndStat {
                cpu: stat.cpu as i64,
                value: this_cpu_end_stat_value * stat.named_stat.scale as f64,
            };
            metadata.update_limits(GraphLimitType::F64(this_cpu_end_stat.value));
            end_cpu_stats.push(this_cpu_end_stat);
            aggregate_nr += stat.named_stat.nr_value;
            aggregate_dr += stat.named_stat.dr_value;
        }
        aggregate_value =
            (aggregate_nr as f64 / aggregate_dr as f64) * stats[0].named_stat.scale as f64;
        metadata.update_limits(GraphLimitType::F64(aggregate_value));
        let aggr_cpu_stat = EndStat {
            cpu: -1,
            value: aggregate_value,
        };
        metric.insert_value(aggregate_value);
        end_cpu_stats.push(aggr_cpu_stat);

        end_stats.time = stats[0].named_stat.time - *time_zero;
        end_stats.cpus = end_cpu_stats;
        end_values.push(end_stats);
    }
    add_metrics(key, &mut metric, metrics, PERF_STAT_FILE_NAME.to_string())?;
    let perf_data = EndPerfData {
        data: end_values,
        metadata,
    };
    Ok(serde_json::to_string(&perf_data)?)
}