diff --git a/bindings/rust/benches/blst_benches.rs b/bindings/rust/benches/blst_benches.rs index c0936b35..9d7ea63a 100644 --- a/bindings/rust/benches/blst_benches.rs +++ b/bindings/rust/benches/blst_benches.rs @@ -61,7 +61,7 @@ fn bench_verify_multi_aggregate(c: &mut Criterion) { let seed = [0u8; 32]; let mut rng = ChaCha20Rng::from_seed(seed); - let num_sigs = vec![8, 16, 32, 64, 128]; + let num_sigs = [8, 16, 32, 64, 128]; let pks_per_sig = 3; for n in num_sigs.iter() { @@ -81,8 +81,6 @@ fn bench_verify_multi_aggregate(c: &mut Criterion) { .collect(); let pks_i = sks_i.iter().map(|sk| sk.sk_to_pk()).collect::>(); - let pks_refs_i: Vec<&PublicKey> = - pks_i.iter().map(|pk| pk).collect(); // Create random message for pks to all sign let msg_len = (rng.next_u64() & 0x3F) + 1; @@ -96,9 +94,7 @@ fn bench_verify_multi_aggregate(c: &mut Criterion) { .collect::>(); // Aggregate signature - let sig_refs_i = - sigs_i.iter().map(|s| s).collect::>(); - let agg_i = match AggregateSignature::aggregate(&sig_refs_i, false) + let agg_i = match AggregateSignature::aggregate_iter(&sigs_i, false) { Ok(agg_i) => agg_i, Err(err) => panic!("aggregate failure: {:?}", err), @@ -107,7 +103,7 @@ fn bench_verify_multi_aggregate(c: &mut Criterion) { // aggregate public keys and push into vec let agg_pk_i = - match AggregatePublicKey::aggregate(&pks_refs_i, false) { + match AggregatePublicKey::aggregate_iter(&pks_i, false) { Ok(agg_pk_i) => agg_pk_i, Err(err) => panic!("aggregate failure: {:?}", err), }; @@ -157,26 +153,18 @@ fn bench_fast_aggregate_verify(c: &mut Criterion) { let mut msg = vec![0u8; msg_len as usize]; rng.fill_bytes(&mut msg); - let sizes = vec![8, 16, 32, 64, 128]; + let sizes = [8, 16, 32, 64, 128]; let bds: Vec<_> = (0..sizes[sizes.len() - 1]) .map(|_| gen_bench_data_for_msg(&mut rng, &msg)) .collect(); - for size in sizes.iter() { - let pks_refs = bds - .iter() - .take(*size) - .map(|s| &s.pk) - .collect::>(); + for size in sizes { + let pks_refs = bds[..size].iter().map(|s| &s.pk).collect::>(); - let sig_refs = bds - .iter() - .take(*size) - .map(|s| &s.sig) - .collect::>(); + let sig_refs = bds[..size].iter().map(|s| &s.sig); - let agg = match AggregateSignature::aggregate(&sig_refs, false) { + let agg = match AggregateSignature::aggregate_iter(sig_refs, false) { Ok(agg) => agg, Err(err) => panic!("aggregate failure: {:?}", err), }; @@ -196,7 +184,7 @@ fn bench_fast_aggregate_verify(c: &mut Criterion) { &agg_ver, |b, (a, p, m, d)| { b.iter(|| { - let result = a.fast_aggregate_verify(true, &m, &d, &p); + let result = a.fast_aggregate_verify(true, m, d, p); assert_eq!(result, BLST_ERROR::BLST_SUCCESS); }); }, @@ -224,33 +212,27 @@ fn bench_aggregate_verify(c: &mut Criterion) { let seed = [0u8; 32]; let mut rng = ChaCha20Rng::from_seed(seed); - let sizes = vec![8, 16, 32, 64, 128]; + let sizes = [8, 16, 32, 64, 128]; // [10, 50, 100, 300, 1000, 4000]; let bds: Vec<_> = (0..sizes[sizes.len() - 1]) .map(|_| gen_bench_data(&mut rng)) .collect(); - for size in sizes.iter() { - let msgs_refs = bds + for size in sizes { + let msgs_refs = bds[..size] .iter() - .take(*size) .map(|s| s.msg.as_slice()) .collect::>(); - let pks_refs = bds + let pks_refs = bds[..size] .iter() - .take(*size) .map(|s| &s.pk) .collect::>(); - let sig_refs = bds - .iter() - .take(*size) - .map(|s| &s.sig) - .collect::>(); + let sig_refs = bds[..size].iter().map(|s| &s.sig); - let agg = match AggregateSignature::aggregate(&sig_refs, false) { + let agg = match AggregateSignature::aggregate_iter(sig_refs, false) { Ok(agg) => agg, Err(err) => panic!("aggregate failure: {:?}", err), }; @@ -262,7 +244,7 @@ fn bench_aggregate_verify(c: &mut Criterion) { &agg_ver, |b, (a, p, m, d)| { b.iter(|| { - let result = a.aggregate_verify(true, &m, &d, &p, false); + let result = a.aggregate_verify(true, m, d, p, false); assert_eq!(result, BLST_ERROR::BLST_SUCCESS); }); }, @@ -278,36 +260,34 @@ fn bench_aggregate(c: &mut Criterion) { let seed = [0u8; 32]; let mut rng = ChaCha20Rng::from_seed(seed); - let sizes: [usize; 6] = [10, 50, 100, 300, 1000, 4000]; + let sizes = [10, 50, 100, 300, 1000, 4000]; let bds: Vec<_> = (0..4000).map(|_| gen_bench_data(&mut rng)).collect(); - for size in sizes.iter() { - let sig_refs = bds - .iter() - .take(*size) - .map(|s| &s.sig) - .collect::>(); - + for size in sizes { group.bench_with_input( BenchmarkId::new("aggregate_signature", size), - &sig_refs, - |b, s| { - b.iter(|| AggregateSignature::aggregate(&s, false)); + &bds, + |b, bds| { + b.iter(|| { + AggregateSignature::aggregate_iter( + bds[..size].iter().map(|s| &s.sig), + false, + ) + }); }, ); - let pks_refs = bds - .iter() - .take(*size) - .map(|s| &s.pk) - .collect::>(); - group.bench_with_input( BenchmarkId::new("aggregate_public_key", size), - &pks_refs, - |b, p| { - b.iter(|| AggregatePublicKey::aggregate(&p, false)); + &bds, + |b, bds| { + b.iter(|| { + AggregatePublicKey::aggregate_iter( + bds[..size].iter().map(|s| &s.pk), + false, + ) + }); }, ); } diff --git a/bindings/rust/src/lib.rs b/bindings/rust/src/lib.rs index 9083bd8a..e3cb6022 100644 --- a/bindings/rust/src/lib.rs +++ b/bindings/rust/src/lib.rs @@ -926,14 +926,22 @@ macro_rules! sig_variant_impl { pks: &[&PublicKey], pks_validate: bool, ) -> Result { - if pks.len() == 0 { - return Err(BLST_ERROR::BLST_AGGR_TYPE_MISMATCH); - } + // Convert Iterator To Iterator + Self::aggregate_iter(pks.iter().copied(), pks_validate) + } + + pub fn aggregate_iter<'a>( + pks: impl IntoIterator, + pks_validate: bool, + ) -> Result { + let mut pks = pks.into_iter(); + let first = + pks.next().ok_or(BLST_ERROR::BLST_AGGR_TYPE_MISMATCH)?; if pks_validate { - pks[0].validate()?; + first.validate()?; } - let mut agg_pk = AggregatePublicKey::from_public_key(pks[0]); - for s in pks.iter().skip(1) { + let mut agg_pk = AggregatePublicKey::from_public_key(first); + for s in pks { if pks_validate { s.validate()?; } @@ -1425,17 +1433,25 @@ macro_rules! sig_variant_impl { sigs: &[&Signature], sigs_groupcheck: bool, ) -> Result { - if sigs.len() == 0 { - return Err(BLST_ERROR::BLST_AGGR_TYPE_MISMATCH); - } + // Convert Iterator To Iterator + Self::aggregate_iter(sigs.iter().copied(), sigs_groupcheck) + } + + pub fn aggregate_iter<'a>( + sigs: impl IntoIterator, + sigs_groupcheck: bool, + ) -> Result { + let mut sigs = sigs.into_iter(); + let first = + sigs.next().ok_or(BLST_ERROR::BLST_AGGR_TYPE_MISMATCH)?; if sigs_groupcheck { // We can't actually judge if input is individual or // aggregated signature, so we can't enforce infinity // check. - sigs[0].validate(false)?; + first.validate(false)?; } - let mut agg_sig = AggregateSignature::from_signature(sigs[0]); - for s in sigs.iter().skip(1) { + let mut agg_sig = AggregateSignature::from_signature(first); + for s in sigs { if sigs_groupcheck { s.validate(false)?; } @@ -1609,9 +1625,8 @@ macro_rules! sig_variant_impl { .collect::>(); assert_ne!(errs, vec![BLST_ERROR::BLST_SUCCESS; num_msgs]); - let sig_refs = - sigs.iter().map(|s| s).collect::>(); - let agg = match AggregateSignature::aggregate(&sig_refs, true) { + let agg = match AggregateSignature::aggregate_iter(&sigs, true) + { Ok(agg) => agg, Err(err) => panic!("aggregate failure: {:?}", err), }; @@ -1651,8 +1666,7 @@ macro_rules! sig_variant_impl { .iter() .map(|sk| sk.sk_to_pk()) .collect::>(); - let pks_refs_i: Vec<&PublicKey> = - pks_i.iter().map(|pk| pk).collect(); + let pks_refs_i: Vec<&PublicKey> = pks_i.iter().collect(); // Create random message for pks to all sign let msg_len = (rng.next_u64() & 0x3F) + 1; @@ -1678,14 +1692,12 @@ macro_rules! sig_variant_impl { vec![BLST_ERROR::BLST_SUCCESS; num_pks_per_sig] ); - let sig_refs_i = - sigs_i.iter().map(|s| s).collect::>(); - let agg_i = - match AggregateSignature::aggregate(&sig_refs_i, false) - { - Ok(agg_i) => agg_i, - Err(err) => panic!("aggregate failure: {:?}", err), - }; + let agg_i = match AggregateSignature::aggregate_iter( + &sigs_i, false, + ) { + Ok(agg_i) => agg_i, + Err(err) => panic!("aggregate failure: {:?}", err), + }; // Test current aggregate signature sigs.push(agg_i.to_signature()); @@ -1710,7 +1722,7 @@ macro_rules! sig_variant_impl { // aggregate public keys and push into vec let agg_pk_i = - match AggregatePublicKey::aggregate(&pks_refs_i, false) + match AggregatePublicKey::aggregate_iter(&pks_i, false) { Ok(agg_pk_i) => agg_pk_i, Err(err) => panic!("aggregate failure: {:?}", err),