Enum seec::circuit::ExecutableCircuit

pub enum ExecutableCircuit<P, G, Idx> {
    DynLayers(Circuit<P, G, Idx>),
    StaticLayers(Circuit<G, Idx>),
}

Variants

DynLayers(Circuit<P, G, Idx>)

StaticLayers(Circuit<G, Idx>)

Implementations

impl<P, G, Idx> ExecutableCircuit<P, G, Idx>

pub fn interactive_count(&self) -> usize

pub fn interactive_count_times_simd(&self) -> usize

pub fn input_count(&self) -> usize

pub fn output_count(&self) -> usize

pub fn input_gates(&self) -> &[GateId<Idx>]

pub fn output_gates(&self) -> &[GateId<Idx>]

pub fn simd_size(&self, circ_id: CircuitId) -> Option<NonZeroUsize>

impl<P: Plain, G: Gate<P>, Idx: GateIdx> ExecutableCircuit<P, G, Idx>

pub fn precompute_layers(self) -> Self

Examples found in repository

crates/seec/examples/aes_cbc.rs (line 135)

fn compile(args: &CompileArgs) -> Result<()> {
    let input_bits = args.input_blocks * 128;
    let circ = build_enc_circuit(input_bits, args.use_sc).context("failed to construct circuit")?;
    let circ = if args.static_layers {
        circ.precompute_layers()
    } else {
        circ
    };
    let out = BufWriter::new(File::create(&args.output).context("failed to create output file")?);
    bincode::serialize_into(out, &circ).context("failed to serialize circuit")?;
    Ok(())
}

crates/seec/examples/fuse.rs (line 105)

fn compile(compile_args: CompileArgs) -> Result<()> {
    let call_mode = match compile_args.inline_circuits {
        true => CallMode::InlineCircuits,
        false => CallMode::CallCircuits,
    };
    let converter = FuseConverter::<u32>::new(call_mode);
    let circ = converter
        .convert(&compile_args.circuit)
        .ok()
        .context("Unable to load and convert FUSE circuit")?;
    let mut circ = ExecutableCircuit::DynLayers(circ);
    if !compile_args.dyn_layers {
        circ = circ.precompute_layers();
    }
    let out =
        BufWriter::new(File::create(compile_args.output).context("failed to create output file")?);
    bincode::serialize_into(out, &circ).context("failed to serialize circuit")?;
    Ok(())
}

crates/seec/examples/bristol.rs (line 140)

fn compile(compile_args: CompileArgs) -> Result<()> {
    let load = match compile_args.simd {
        Some(_) => Load::SubCircuit,
        None => Load::Circuit,
    };
    let mut bc: BaseCircuit = BaseCircuit::load_bristol(&compile_args.circuit, load)
        .expect("failed to load bristol circuit");

    let mut circ = match compile_args.simd {
        Some(size) => {
            bc.set_simd_size(size);
            let circ_input_size = bc.sub_circuit_input_count();
            let inputs = inputs::<u32>(circ_input_size);
            let bc = bc.into_shared();

            let (output, circ_id) = CircuitBuilder::with_global(|builder| {
                builder.get_main_circuit().lock().set_simd_size(size);
                let circ_id = builder.push_circuit(bc);
                let output = builder.connect_sub_circuit(&inputs, circ_id);
                (output, circ_id)
            });
            let main = output.connect_to_main(circ_id);
            main.iter().for_each(|s| {
                s.output();
            });
            let circ = CircuitBuilder::global_into_circuit();
            ExecutableCircuit::DynLayers(circ)
        }
        None => ExecutableCircuit::DynLayers(bc.into()),
    };
    if !compile_args.dyn_layers {
        circ = circ.precompute_layers();
    }
    let out =
        BufWriter::new(File::create(&compile_args.output).context("failed to create output file")?);
    bincode::serialize_into(out, &circ).context("failed to serialize circuit")?;
    Ok(())
}

impl ProgArgs {
    fn log(&self) -> Option<&PathBuf> {
        match self {
            ProgArgs::Compile(args) => args.log.as_ref(),
            ProgArgs::Execute(args) => args.log.as_ref(),
        }
    }
}

async fn execute(execute_args: ExecuteArgs) -> Result<()> {
    let circ_name = execute_args
        .circuit
        .file_stem()
        .unwrap()
        .to_string_lossy()
        .to_string();
    let circuit = load_circ(&execute_args).context("failed to load circuit")?;

    let create_party = |id, circ| {
        let mut party = BenchParty::<BooleanGmw, u32>::new(id)
            .explicit_circuit(circ)
            .repeat(execute_args.repeat)
            .insecure_setup(execute_args.insecure_setup)
            .interleave_setup(execute_args.interleave_setup)
            .metadata(circ_name.clone());
        if let Some(domain) = &execute_args.domain {
            party = party.tls_domain(domain.clone());
        }
        match (&execute_args.cert, &execute_args.cert_pk) {
            (Some(cert), Some(pk)) => {
                party = party.tls_config(ServerTlsConfig {
                    private_key_file: pk.clone(),
                    certificate_chain_file: cert.clone(),
                });
            }
            (Some(_), None) | (None, Some(_)) => {
                anyhow::bail!("Must provide both --cert and --cert-pk or neither")
            }
            _ => {}
        }
        if let Some(path) = &execute_args.stored_mts {
            party = party.stored_mts(path);
        }
        if let Some(server) = execute_args.server {
            party = party.server(server)
        }
        Ok(party)
    };

    let results = if let Some(id) = execute_args.id {
        let party = create_party(id, circuit)?;
        party.bench().await.context("Failed to run benchmark")?
    } else {
        let party0 = create_party(0, circuit.clone())?;
        let party1 = create_party(1, circuit)?;
        let bench0 = tokio::spawn(party0.bench());
        let bench1 = tokio::spawn(party1.bench());
        let (res0, _res1) = tokio::try_join!(bench0, bench1).context("Failed to join parties")?;
        res0.context("Failed to run benchmark")?
    };

    // Depending on whether a --stats file is set, create a file writer or stdout
    let mut writer: Box<dyn Write> = match execute_args.stats {
        Some(path) => {
            let file = File::create(path)?;
            Box::new(file)
        }
        None => Box::new(stdout()),
    };
    // serde_json is used to write the statistics in json format. `.csv` is currently not
    // supported.
    serde_json::to_writer_pretty(&mut writer, &results)?;
    writeln!(writer)?;

    Ok(())
}

fn load_circ(args: &ExecuteArgs) -> Result<ExecutableCircuit<bool, BooleanGate, u32>> {
    let res = bincode::deserialize_from(BufReader::new(
        File::open(&args.circuit).context("Failed to open circuit file")?,
    ));
    match res {
        Ok(circ) => Ok(circ),
        Err(_) => {
            // try to load as bristol
            Ok(ExecutableCircuit::DynLayers(
                BaseCircuit::load_bristol(&args.circuit, Load::Circuit)
                    .context("Circuit is neither .seec file or bristol")?
                    .into(),
            )
            .precompute_layers())
        }
    }
}

pub fn gate_count(&self) -> usize

Examples found in repository

crates/seec/examples/privmail.rs (line 249)

async fn main() -> anyhow::Result<()> {
    let args: Args = Args::parse();
    let search_query: SearchQuery =
        serde_yaml::from_reader(File::open(args.query_file_path).expect("Opening query file"))
            .expect("Deserializing query file");
    let mails: Vec<Mail> = fs::read_dir(args.mail_dir_path)
        .expect("Reading mail dir")
        .map(|entry| {
            let entry = entry.expect("Mail dir iteration");
            serde_yaml::from_reader(File::open(entry.path()).expect("Opening mail file"))
                .expect("Deserializing mail file")
        })
        .collect();

    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .init();

    let (input, _) = priv_mail_search(
        &search_query.keywords,
        &search_query.modifier_chain_share,
        &mails,
        args.duplication_factor,
    );

    let circuit: ExecutableCircuit<bool, _, _> =
        ExecutableCircuit::DynLayers(CircuitBuilder::global_into_circuit());
    // if args.save_circuit {
    //     circuit.save_dot("privmail.dot")?;
    // }

    let (mut sender, bytes_written, mut receiver, bytes_read) = match args.my_id {
        0 => seec_channel::tcp::listen(args.server).await?,
        1 => seec_channel::tcp::connect(args.server).await?,
        illegal => anyhow::bail!("Illegal party id {illegal}. Must be 0 or 1."),
    };

    let mut executor = {
        let mt_provider = InsecureMTProvider::default();
        BoolGmwExecutor::new(&circuit, args.my_id, mt_provider).await?
    };

    let (mut sender, mut receiver) =
        sub_channels_for!(&mut sender, &mut receiver, 16, Message<BooleanGmw>).await?;

    let output = executor
        .execute(Input::Scalar(input), &mut sender, &mut receiver)
        .await?;
    info!(
        my_id = %args.my_id,
        output = ?output,
        bytes_written = bytes_written.get(),
        bytes_read = bytes_read.get(),
        gate_count = circuit.gate_count()
    );
    Ok(())
}

crates/seec/examples/privmail_sc.rs (line 252)

async fn main() -> anyhow::Result<()> {
    let args: Args = Args::parse();
    let search_query: SearchQuery =
        serde_yaml::from_reader(File::open(args.query_file_path).expect("Opening query file"))
            .expect("Deserializing query file");
    let mails: Vec<Mail> = fs::read_dir(args.mail_dir_path)
        .expect("Reading mail dir")
        .map(|entry| {
            let entry = entry.expect("Mail dir iteration");
            serde_yaml::from_reader(File::open(entry.path()).expect("Opening mail file"))
                .expect("Deserializing mail file")
        })
        .collect();

    tracing_subscriber::fmt()
        .with_env_filter(EnvFilter::from_default_env())
        .init();

    let now = Instant::now();
    let (input, _) = priv_mail_search(
        &search_query.keywords,
        &search_query.modifier_chain_share,
        &mails,
        args.duplication_factor,
    );
    let circuit = ExecutableCircuit::DynLayers(CircuitBuilder::global_into_circuit());
    info!("Building circuit took: {}", now.elapsed().as_secs_f32());
    // circuit = circuit.clone().into_base_circuit().into();
    // if args.save_circuit {
    //     bc.save_dot("privmail.dot")?;
    // }
    // dbg!(&circuit);
    let (mut sender, bytes_written, mut receiver, bytes_read) = match args.my_id {
        0 => seec_channel::tcp::listen(args.server).await?,
        1 => seec_channel::tcp::connect(args.server).await?,
        illegal => anyhow::bail!("Illegal party id {illegal}. Must be 0 or 1."),
    };

    let (ch1, mut ch2) = sub_channels_for!(
        &mut sender,
        &mut receiver,
        64,
        seec_channel::Sender<ot_ext::ExtOTMsg>,
        Message<BooleanGmw>
    )
    .await?;

    let mut executor = {
        let mt_provider = OtMTProvider::new(
            OsRng,
            ot_ext::Sender::default(),
            ot_ext::Receiver::default(),
            ch1.0,
            ch1.1,
        );
        BoolGmwExecutor::new(&circuit, args.my_id, mt_provider).await?
    };

    let output = executor
        .execute(Input::Scalar(input), &mut ch2.0, &mut ch2.1)
        .await?;
    info!(
        my_id = %args.my_id,
        output = ?output,
        bytes_written = bytes_written.get(),
        bytes_read = bytes_read.get(),
        gate_count = circuit.gate_count(),
    );
    Ok(())
}

pub fn gate_counts( &self ) -> impl Iterator<Item = (usize, Option<NonZeroUsize>)> + '_

Returns iterator over tuples of (gate_count, simd_size) for each sub_circuit

pub fn iter( &self ) -> impl Iterator<Item = (G, SubCircuitGate<Idx>)> + Clone + '_

pub fn iter_with_parents( &self ) -> impl Iterator<Item = (G, SubCircuitGate<Idx>, impl Iterator<Item = SubCircuitGate<Idx>> + '_)> + '_

pub fn interactive_iter( &self ) -> impl Iterator<Item = (G, SubCircuitGate<Idx>)> + Clone + '_

pub fn interactive_with_parents_iter( &self ) -> impl Iterator<Item = (G, SubCircuitGate<Idx>, impl Iterator<Item = SubCircuitGate<Idx>> + '_)> + '_

pub fn layer_iter( &self ) -> impl Iterator<Item = ExecutableLayer<'_, P, G, Idx>> + '_

Trait Implementations

impl<P: Clone, G: Clone, Idx: GateIdx> Clone for ExecutableCircuit<P, G, Idx>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<P: Debug, G: Debug, Idx: Debug> Debug for ExecutableCircuit<P, G, Idx>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, P, G, Idx> Deserialize<'de> for ExecutableCircuit<P, G, Idx>

where G: Serialize + DeserializeOwned, Idx: GateIdx + Ord + Eq + Hash + Serialize + DeserializeOwned,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P, G, Idx> Serialize for ExecutableCircuit<P, G, Idx>

where G: Serialize + DeserializeOwned, Idx: GateIdx + Ord + Eq + Hash + Serialize + DeserializeOwned,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.