ed255/pod2
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

better measuring (#295)

Browse source
This commit is contained in:
Eduard S. 2025-06-18 17:23:32 +02:00 • committed by GitHub
parent 0541817116
commit df8fce76d6
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
5 changed files with 40 additions and 21 deletions
Download patch file Download diff file Expand all files Collapse all files

42
src/backends/plonky2/circuits/mainpod.rs
View file

@ -152,7 +152,7 @@ impl OperationVerifyGadget {
merkle_claims: &[MerkleClaimTarget],
custom_predicate_verification_table: &[HashOutTarget],
) -> Result<()> {
let measure = measure_gates_begin!(builder, "OperationVerify");
let measure = measure_gates_begin!(builder, "OpVerify");
let _true = builder._true();
let _false = builder._false();
@ -861,7 +861,7 @@ impl CustomOperationVerifyGadget {
st_tmpl: &StatementTmplTarget,
args: &[ValueTarget],
) -> StatementTarget {
let measure = measure_gates_begin!(builder, "StatementArgFromTemplate");
let measure = measure_gates_begin!(builder, "StArgFromTmpl");
let args = st_tmpl
.args
.iter()
@ -886,7 +886,7 @@ impl CustomOperationVerifyGadget {
op_args: &[StatementTarget],
args: &[ValueTarget], // arguments to the custom predicate, public and private
) -> Result<(StatementTarget, OperationTypeTarget)> {
let measure = measure_gates_begin!(builder, "CustomOperationVerify");
let measure = measure_gates_begin!(builder, "CustomOpVerify");
// Some sanity checks
assert_eq!(self.params.max_operation_args, op_args.len());
assert_eq!(self.params.max_custom_predicate_wildcards, args.len());
@ -1100,7 +1100,7 @@ impl MainPodVerifyGadget {
&self,
builder: &mut CircuitBuilder,
) -> Result<(Vec<HashOutTarget>, Vec<CustomPredicateBatchTarget>)> {
let measure = measure_gates_begin!(builder, "BuildCustomPredicateTable");
let measure = measure_gates_begin!(builder, "BuildCustomPredTbl");
let params = &self.params;
let mut custom_predicate_table =
Vec::with_capacity(params.max_custom_predicate_batches * params.max_custom_batch_size);
@ -1142,7 +1142,7 @@ impl MainPodVerifyGadget {
builder: &mut CircuitBuilder,
custom_predicate_table: &[HashOutTarget],
) -> Result<(Vec<HashOutTarget>, Vec<CustomPredicateVerifyEntryTarget>)> {
let measure = measure_gates_begin!(builder, "BuildCustomPredicateVerificationTable");
let measure = measure_gates_begin!(builder, "BuildCustomPredVerifyTbl");
let params = &self.params;
let mut custom_predicate_verifications =
Vec::with_capacity(params.max_custom_predicate_verifications);
@ -1200,7 +1200,7 @@ impl MainPodVerifyGadget {
let measure = measure_gates_begin!(builder, "MainPodVerify");
let params = &self.params;
// 1. Verify all input signed pods
// 1a. Verify all input signed pods
let mut signed_pods = Vec::new();
for _ in 0..params.max_input_signed_pods {
let signed_pod = SignedPodVerifyGadget {
@ -1226,14 +1226,23 @@ impl MainPodVerifyGadget {
1 + self.params.max_input_signed_pods * self.params.max_signed_pod_values
);
// 1b. Verify all input recursive pods
let id_gadget = CalculateIdGadget {
params: params.clone(),
};
let mut input_pods_self_statements: Vec<Vec<StatementTarget>> = Vec::new();
let normalize_statement_gadget = NormalizeStatementGadget {
params: self.params.clone(),
};
let vds_root = builder.add_virtual_hash();
let mut input_pods_self_statements: Vec<Vec<StatementTarget>> = Vec::new();
let mut vd_mt_proofs: Vec<MerkleClaimAndProofTarget> = Vec::new();
for verified_proof in verified_proofs {
let measure_in_pod = measure_gates_begin!(builder, "VerifyInPod");
//
// Verify id from the statements
//
let expected_id = HashOutTarget::try_from(
&verified_proof.public_inputs[PI_OFFSET_ID..PI_OFFSET_ID + HASH_SIZE],
)
@ -1252,14 +1261,12 @@ impl MainPodVerifyGadget {
let id = id_gadget.eval(builder, &input_pod_self_statements);
builder.connect_hashes(expected_id, id);
input_pods_self_statements.push(input_pod_self_statements);
}
let vds_root = builder.add_virtual_hash();
//
// Verify that all input pod proofs use verifier data from the public input VD
// array. This requires merkle proofs
//
// verify that all input pod proofs use verifier data from the public input VD array This
// requires merkle proofs
let mut vd_mt_proofs: Vec<MerkleClaimAndProofTarget> = vec![];
for verified_proof in verified_proofs {
// add target for the vd_mt_proof
let vd_mt_proof = MerkleProofGadget {
max_depth: params.max_depth_mt_vds,
@ -1277,17 +1284,18 @@ impl MainPodVerifyGadget {
verified_proof.verifier_data_hash,
HashOutTarget::from_vec(vd_mt_proof.value.elements.to_vec()),
);
vd_mt_proofs.push(vd_mt_proof);
}
// Verify that VD array that input pod uses is the same we use now.
for verified_proof in verified_proofs {
//
// Verify that VD array that input pod uses is the same we use now.
//
let verified_proof_vds_root = HashOutTarget::try_from(
&verified_proof.public_inputs[PI_OFFSET_VDSROOT..PI_OFFSET_VDSROOT + HASH_SIZE],
)
.expect("4 elements");
builder.connect_hashes(vds_root, verified_proof_vds_root);
measure_gates_end!(builder, measure_in_pod);
}
// Add the input (private and public) statements and corresponding operations

7
src/backends/plonky2/mainpod/mod.rs
View file

@ -30,6 +30,7 @@ use crate::{
Hash, MainPodInputs, NativeOperation, OperationType, Params, Pod, PodId, PodProver,
PodType, RecursivePod, StatementArg, ToFields, VDSet, F, KEY_TYPE, SELF,
},
timed,
};
/// Hash a list of public statements to derive the PodId. To make circuits with different number
@ -540,7 +541,10 @@ impl Prover {
custom_predicate_batches,
custom_predicate_verifications,
};
let proof_with_pis = main_pod.prove(&input, proofs, verifier_datas)?;
let proof_with_pis = timed!(
"MainPod::prove",
main_pod.prove(&input, proofs, verifier_datas)?
);
Ok(MainPod {
params: params.clone(),
@ -873,6 +877,7 @@ pub mod tests {
let dist_1 = helper
.dist_1(&alice_attestation)?
.prove(&mut prover, &params)?;
crate::measure_gates_print!();
dist_1.pod.verify()?;
let dist_2 = helper
.dist_n_plus_1(&dist_1, &bob_attestation)?

3
src/backends/plonky2/primitives/merkletree/circuit.rs
View file

@ -224,8 +224,7 @@ pub struct MerkleProofExistenceTarget {
impl MerkleProofExistenceGadget {
/// creates the targets and defines the logic of the circuit
pub fn eval(&self, builder: &mut CircuitBuilder<F, D>) -> Result<MerkleProofExistenceTarget> {
let measure =
measure_gates_begin!(builder, format!("MerkleProofExistence_{}", self.max_depth));
let measure = measure_gates_begin!(builder, format!("MerkleProofExist_{}", self.max_depth));
let enabled = builder.add_virtual_bool_target_safe();
let root = builder.add_virtual_hash();
let key = builder.add_virtual_value();

6
src/backends/plonky2/recursion/circuit.rs
View file

@ -41,6 +41,7 @@ use crate::{
curve::ECAddHomogOffset, field::NNFMulSimple, generic::GateAdapter,
},
},
measure_gates_begin, measure_gates_end,
middleware::F,
timed,
};
@ -190,14 +191,17 @@ impl<I: InnerCircuit> RecursiveCircuit<I> {
common_data: &CommonCircuitData<F, D>,
inner_params: &I::Params,
) -> Result<RecursiveCircuitTarget<I>> {
let measure = measure_gates_begin!(builder, "RecCircuit");
// proof verification
let verifier_datas_targ: Vec<VerifierCircuitTarget> = (0..arity)
.map(|_| builder.add_virtual_verifier_data(builder.config.fri_config.cap_height))
.collect();
let proofs_targ: Vec<ProofWithPublicInputsTarget<D>> = (0..arity)
.map(|i| {
let measure_verify = measure_gates_begin!(builder, "VerifyProof");
let proof_targ = builder.add_virtual_proof_with_pis(common_data);
builder.verify_proof::<C>(&proof_targ, &verifier_datas_targ[i], common_data);
measure_gates_end!(builder, measure_verify);
proof_targ
})
.collect();
@ -223,6 +227,8 @@ impl<I: InnerCircuit> RecursiveCircuit<I> {
// Build the InnerCircuit logic
let innercircuit_targ: I = I::build(builder, inner_params, &verified_proofs)?;
measure_gates_end!(builder, measure);
pad_circuit(builder, common_data);
Ok(RecursiveCircuitTarget {

3
src/backends/plonky2/signedpod.rs
View file

@ -23,6 +23,7 @@ use crate::{
containers::Dictionary, AnchoredKey, DynError, Hash, Key, Params, Pod, PodId, PodSigner,
PodType, RawValue, Statement, Value, KEY_SIGNER, KEY_TYPE, SELF,
},
timed,
};
pub struct Signer(pub SecretKey);
@ -42,7 +43,7 @@ impl Signer {
let dict = Dictionary::new(params.max_depth_mt_containers, kvs)?;
let id = RawValue::from(dict.commitment()); // PodId as Value
let signature: Signature = self.0.sign(id, &nonce);
let signature: Signature = timed!("SignedPod::sign", self.0.sign(id, &nonce));
Ok(SignedPod {
id: PodId(Hash::from(id)),
signature,