Method compute_graph_resharing

ciphercore-base/src/mpc/resharing.rs:79–182

Computes the set of nodes that need resharing of their output

(
        &mut self,
        graph: &Graph,
        private_nodes: &HashSet<Node>,
    )

    // Computes the set of nodes that need resharing of their output
    fn compute_graph_resharing(
        &mut self,
        graph: &Graph,
        private_nodes: &HashSet<Node>,
    ) -> Result<()> {
        self.nodes_to_reshare = HashSet::new();
        // nodes that contain 3-out-of-3 shares
        // All the other shared nodes have 2-out-of-3 shares
        self.unreshared_nodes = HashSet::new();

        for node in graph.get_nodes() {
            // if node is public, no resharing is needed
            if !private_nodes.contains(&node) {
                continue;
            }
            let op = node.get_operation();
            if !op.is_mpc_compiled() {
                return Err(runtime_error!("This operation shouldn't be MPC compiled"));
            }
            match op {
                Operation::Input(_)
                 => {
                    // No resharing is needed
                }
                Operation::Add
                | Operation::Subtract
                | Operation::Sum(_)
                | Operation::CumSum(_)
                | Operation::Get(_)
                | Operation::Stack(_)
                | Operation::Concatenate(_)
                | Operation::Reshape(_)
                | Operation::PermuteAxes(_)
                | Operation::Zip
                | Operation::Repeat(_)
                | Operation::TupleGet(_)
                | Operation::CreateNamedTuple(_)
                | Operation::NamedTupleGet(_)
                | Operation::VectorToArray
                | Operation::VectorGet
                | Operation::CreateTuple
                | Operation::ArrayToVector
                | Operation::CreateVector(_) => {
                    self.local_operation_handler(node)?;
                }
                Operation::Multiply
                | Operation::Dot
                | Operation::Matmul
                | Operation::Gemm(_, _) => {
                    let dependencies = node.get_node_dependencies();

                    let mut all_inputs_are_shared = true;
                    for dep_node in &dependencies {
                        if !private_nodes.contains(dep_node) {
                            all_inputs_are_shared = false;
                        }
                    }