Function print_stats

ciphercore-base/src/bin/ciphercore_inspect.rs:168–277

(graph: Graph)

}

pub(crate) fn print_stats(graph: Graph) -> Result<()> {
    let mut cnt = HashMap::<String, u64>::new();
    let mut inputs = Vec::<InputInfo>::new();
    let mut network_traffic_in_bits = 0;
    let mut total_integer_operations = 0;
    let mut total_bit_operations = 0;
    let mut total_8bits_operations = 0;
    let mut total_16bits_operations = 0;
    let mut total_32bits_operations = 0;
    let mut total_64bits_operations = 0;
    let mut total_128bits_operations = 0;
    for node in graph.get_nodes() {
        let op = node.get_operation();
        let op_name = format!("{op}");
        *cnt.entry(op_name).or_insert(0) += 1;
        match op {
            Operation::Input(_) => {
                let input = InputInfo {
                    name: node.get_name()?.unwrap_or_else(|| "unnamed".to_owned()),
                    type_string: format!("{}", node.get_type()?),
                };
                inputs.push(input);
            }
            Operation::NOP => {
                if is_network_node(node.clone())? {
                    network_traffic_in_bits += get_size_in_bits(node.get_type()?)?;
                }
            }
            Operation::Add
            | Operation::Subtract
            | Operation::Multiply
            | Operation::Dot
            | Operation::Matmul
            | Operation::Truncate(_)
            | Operation::Sum(_) => {
                let st = node.get_type()?.get_scalar_type();
                let ops = calculate_integer_operations(node.clone())?;
                match st {
                    BIT => total_bit_operations += ops,
                    UINT8 | INT8 => total_8bits_operations += ops,
                    UINT16 | INT16 => total_16bits_operations += ops,
                    UINT32 | INT32 => total_32bits_operations += ops,
                    UINT64 | INT64 => total_64bits_operations += ops,
                    UINT128 | INT128 => total_128bits_operations += ops,
                };
                total_integer_operations += ops;
            }
            _ => {}
        }
    }
    let mut entries: Vec<(String, u64)> = cnt.iter().map(|e| (e.0.clone(), *e.1)).collect();
    let network_rounds = calculate_network_rounds(graph.clone())?;

    entries.sort_by_key(|e| -(e.1 as i64));
    println!("-------Stats--------");
    println!("Inputs: ",);
    for (i, input) in inputs.iter().enumerate() {
        println!("  {}. Name:{}", i + 1, input.name);