src/testing/sl4f/src/ram/types.rs

// Copyright 2020 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use fidl_fuchsia_hardware_ram_metrics::{
    BandwidthInfo, BandwidthMeasurementConfig, GrantedCyclesResult,
};
use fuchsia_zircon as zx;
use serde::{Deserialize, Serialize};

pub enum RamMethod {
    MeasureBandwidth,
    GetDdrWindowingResults,
    UndefinedFunc,
}

impl From<&str> for RamMethod {
    fn from(method: &str) -> RamMethod {
        match method {
            "MeasureBandwidth" => RamMethod::MeasureBandwidth,
            "GetDdrWindowingResults" => RamMethod::GetDdrWindowingResults,
            _ => RamMethod::UndefinedFunc,
        }
    }
}

/// BandwidthMeasurementConfig object is not serializable so we create
/// SerializableBandwidthMeasurementConfig which is serializable.
#[derive(Clone, Debug, Deserialize, PartialEq, Eq)]
pub struct SerializableBandwidthMeasurementConfig {
    pub cycles_to_measure: u64,
    pub channels: [u64; 8],
}

impl From<SerializableBandwidthMeasurementConfig> for BandwidthMeasurementConfig {
    fn from(bandwidth_measurement_config: SerializableBandwidthMeasurementConfig) -> Self {
        BandwidthMeasurementConfig {
            cycles_to_measure: bandwidth_measurement_config.cycles_to_measure,
            channels: bandwidth_measurement_config.channels,
        }
    }
}

/// GrantedCyclesResult object is not serializable so we create SerializableGrantedCyclesResult
/// which is serializable.
#[derive(Clone, Debug, Serialize, PartialEq, Eq, Copy)]
pub struct SerializableGrantedCyclesResult {
    pub read_cycles: u64,
    pub write_cycles: u64,
    pub readwrite_cycles: u64,
}

impl From<GrantedCyclesResult> for SerializableGrantedCyclesResult {
    fn from(granted_cycles_result: GrantedCyclesResult) -> Self {
        SerializableGrantedCyclesResult {
            read_cycles: granted_cycles_result.read_cycles,
            write_cycles: granted_cycles_result.write_cycles,
            readwrite_cycles: granted_cycles_result.readwrite_cycles,
        }
    }
}
impl From<SerializableGrantedCyclesResult> for GrantedCyclesResult {
    fn from(grantedcyclesresult: SerializableGrantedCyclesResult) -> Self {
        GrantedCyclesResult {
            read_cycles: grantedcyclesresult.read_cycles,
            write_cycles: grantedcyclesresult.write_cycles,
            readwrite_cycles: grantedcyclesresult.readwrite_cycles,
        }
    }
}

/// BandwidthInfo object is not serializable so we create SerializableBandwidthInfo
/// which is serializable.
#[derive(Clone, Debug, Serialize, PartialEq, Eq)]
pub struct SerializableBandwidthInfo {
    pub timestamp: zx::sys::zx_time_t,
    pub frequency: u64,
    pub bytes_per_cycle: u64,
    pub channels: [SerializableGrantedCyclesResult; 8],
    pub total: SerializableGrantedCyclesResult,
}

impl From<BandwidthInfo> for SerializableBandwidthInfo {
    fn from(bandwidth_info: BandwidthInfo) -> Self {
        let mut temp_channels = [SerializableGrantedCyclesResult {
            read_cycles: 0,
            write_cycles: 0,
            readwrite_cycles: 0,
        }; 8];
        for (serialized_channel, channel) in
            temp_channels.iter_mut().zip(bandwidth_info.channels.iter())
        {
            *serialized_channel = SerializableGrantedCyclesResult::from(*channel);
        }

        SerializableBandwidthInfo {
            timestamp: bandwidth_info.timestamp,
            frequency: bandwidth_info.frequency,
            bytes_per_cycle: bandwidth_info.bytes_per_cycle,
            channels: temp_channels,
            total: SerializableGrantedCyclesResult::from(bandwidth_info.total),
        }
    }
}

impl From<SerializableBandwidthInfo> for BandwidthInfo {
    fn from(bandwidthinfo: SerializableBandwidthInfo) -> Self {
        let mut temp_channels =
            [GrantedCyclesResult { read_cycles: 0, write_cycles: 0, readwrite_cycles: 0 }; 8];
        for (c, from_c) in temp_channels.iter_mut().zip(bandwidthinfo.channels.iter()) {
            *c = GrantedCyclesResult::from(*from_c);
        }

        BandwidthInfo {
            timestamp: bandwidthinfo.timestamp,
            frequency: bandwidthinfo.frequency,
            bytes_per_cycle: bandwidthinfo.bytes_per_cycle,
            channels: temp_channels,
            total: GrantedCyclesResult::from(bandwidthinfo.total),
        }
    }
}