Skip to content

Commit

Permalink
update benchmark
Browse files Browse the repository at this point in the history
  • Loading branch information
@arvidn
arvidn committed May 10, 2024
1 parent a823c4c commit 1c3c14b
Show file tree
Hide file tree
Showing 2 changed files with 56 additions and 145 deletions.
107 changes: 54 additions & 53 deletions crates/chia-bls/benches/cache.rs
View file
Original file line number Diff line number Diff line change
@@ -1,81 +1,82 @@
use chia_bls::aggregate_verify;
use chia_bls::{sign, BLSCache, PublicKey, SecretKey, Signature};
use criterion::{criterion_group, criterion_main, Criterion};
use chia_bls::{BLSCache, PublicKey, Signature, SecretKey, aggregate, sign};
use chia_bls::aggregate_verify as agg_ver;
use rand::rngs::StdRng;
use rand::{Rng, SeedableRng};

fn cache_benchmark(c: &mut Criterion) {
let mut bls_cache: BLSCache = BLSCache::default(); // 50000
// benchmark at 100% cache hit rate
let mut pk_list: Vec<PublicKey> = [].to_vec();
let mut msg_list: Vec<&[u8]> = vec![];
let mut aggsig: Option<Signature> = None;
for i in 0..=2000 { //cache is half full
let byte_array: [u8; 32] = [i as u8; 32];
let sk: SecretKey = SecretKey::from_seed(&byte_array);
let pk: PublicKey = sk.public_key();
let msg: &[u8] = &[106; 32];
let sig: Signature = sign(&sk, msg);
pk_list.push(pk.clone());
msg_list.push(msg);
assert!(bls_cache.aggregate_verify([pk].iter(), [msg].iter(), &sig));
if aggsig.is_none() {aggsig = Some(sig);} else {aggsig = Some(aggregate([aggsig.unwrap(), sig]));}
let mut rng = StdRng::seed_from_u64(1337);
let mut data = [0u8; 32];
rng.fill(data.as_mut_slice());

let sk = SecretKey::from_seed(&data);
let msg = b"The quick brown fox jumps over the lazy dog";

let mut pks = Vec::<PublicKey>::new();

let mut agg_sig = Signature::default();
for i in 0..1000 {
let derived = sk.derive_hardened(i as u32);
let pk = derived.public_key();
let sig = sign(&derived, msg);
agg_sig.aggregate(&sig);
pks.push(pk);
}

c.bench_function("bls_cache.aggregate_verify, 100% cache hit", |b| {
let mut bls_cache: BLSCache = BLSCache::default();

c.bench_function("bls_cache.aggregate_verify, 0% cache hits", |b| {
let mut cache = bls_cache.clone();
b.iter(|| {
assert!(bls_cache.aggregate_verify(pk_list.iter(), msg_list.iter(), &aggsig.clone().unwrap()));
assert!(cache.aggregate_verify(&pks, [&msg].iter().cycle(), &agg_sig));
});
});
let full_aggsig = aggsig.clone().unwrap();

let mut bls_cache = BLSCache::default();
let mut aggsig: Option<Signature> = None;
for i in 0..=1000 {
let byte_array: [u8; 32] = [i as u8; 32];
let sk: SecretKey = SecretKey::from_seed(&byte_array);
let sig: Signature = sign(&sk, msg_list[i as usize]);
if aggsig.is_none() {aggsig = Some(sig.clone());} else {aggsig = Some(aggregate([aggsig.unwrap(), sig.clone()]));}
assert!(bls_cache.aggregate_verify([pk_list[i as usize].clone()].iter(), [msg_list[i as usize]].iter(), &sig));
}
// populate 10% of keys
bls_cache.aggregate_verify(&pks[0..100], [&msg].iter().cycle(), &agg_sig);
c.bench_function("bls_cache.aggregate_verify, 10% cache hits", |b| {
let mut cache = bls_cache.clone();
b.iter(|| {
assert!(cache.aggregate_verify(&pks, [&msg].iter().cycle(), &agg_sig));
});
});

c.bench_function("bls_cache.aggregate_verify, 50% cache hit", |b| {
// populate another 10% of keys
bls_cache.aggregate_verify(&pks[100..200], [&msg].iter().cycle(), &agg_sig);
c.bench_function("bls_cache.aggregate_verify, 20% cache hits", |b| {
let mut cache = bls_cache.clone();
b.iter(|| {
assert!(bls_cache.clone().aggregate_verify(pk_list.iter(), msg_list.iter(), &full_aggsig.clone()));
assert!(cache.aggregate_verify(&pks, [&msg].iter().cycle(), &agg_sig));
});
});

let bls_cache = BLSCache::default();
let mut aggsig: Option<Signature> = None;
for i in 0..=500 {
let byte_array: [u8; 32] = [i as u8; 32];
let sk: SecretKey = SecretKey::from_seed(&byte_array);
let sig: Signature = sign(&sk, msg_list[i as usize]);
if aggsig.is_none() {aggsig = Some(sig.clone());} else {aggsig = Some(aggregate([aggsig.unwrap(), sig.clone()]));}
assert!(bls_cache.clone().aggregate_verify([pk_list[i as usize].clone()].iter(), [msg_list[i as usize]].iter(), &sig));
}

c.bench_function("bls_cache.aggregate_verify, 25% cache hit", |b| {
// populate another 30% of keys
bls_cache.aggregate_verify(&pks[200..500], [&msg].iter().cycle(), &agg_sig);
c.bench_function("bls_cache.aggregate_verify, 50% cache hits", |b| {
let mut cache = bls_cache.clone();
b.iter(|| {
assert!(bls_cache.clone().aggregate_verify(pk_list.iter(), msg_list.iter(), &full_aggsig.clone()));
assert!(cache.aggregate_verify(&pks, [&msg].iter().cycle(), &agg_sig));
});
});

let bls_cache = BLSCache::default();
c.bench_function("bls_cache.aggregate_verify, 0% cache hit", |b| {
// populate all other keys
bls_cache.aggregate_verify(&pks[500..1000], [&msg].iter().cycle(), &agg_sig);
c.bench_function("bls_cache.aggregate_verify, 100% cache hits", |b| {
let mut cache = bls_cache.clone();
b.iter(|| {
assert!(bls_cache.clone().aggregate_verify(pk_list.iter(), msg_list.iter(), &full_aggsig.clone()));
assert!(cache.aggregate_verify(&pks, [&msg].iter().cycle(), &agg_sig));
});
});

let mut data = Vec::<(PublicKey, &[u8])>::new();
for (pk, msg) in pk_list.iter().zip(msg_list.iter()) {
data.push((pk.clone(), msg.as_ref()));
}
c.bench_function("agg_ver, no cache", |b| {
c.bench_function("bls_cache.aggregate_verify, no cache", |b| {
b.iter(|| {
assert!(agg_ver(&full_aggsig, data.clone()));
assert!(aggregate_verify(
&agg_sig,
pks.iter().map(|pk| (pk, &msg[..]))
));
});
});
}

criterion_group!(cache, cache_benchmark);
criterion_main!(cache);
criterion_main!(cache);
94 changes: 2 additions & 92 deletions crates/chia-bls/src/cached_bls.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -55,14 +55,11 @@ impl BLSCache {
pks: P,
msgs: M,
sig: &Signature,
) -> bool
where
T: Copy,
{
) -> bool {
let iter = pks.into_iter().zip(msgs).map(|(pk, msg)| -> GTElement {
let mut hasher = Sha256::new();
hasher.update(pk.borrow().to_bytes());
hasher.update(msg); // pk + msg
hasher.update(msg.as_ref()); // pk + msg
let h: [u8; 32] = hasher.finalize().into();

if let Some(pairing) = self.cache.get(&h).cloned() {
Expand Down Expand Up @@ -129,9 +126,6 @@ pub mod tests {
use crate::aggregate;
use crate::sign;
use crate::SecretKey;
use std::time::{Duration, Instant};
use crate::aggregate_verify as agg_ver;


#[test]
pub fn test_instantiation() {
Expand Down Expand Up @@ -234,88 +228,4 @@ pub mod tests {
// assert first key has been removed
assert!(bls_cache.cache.get(&h).is_none());
}

#[test]
pub fn test_benchmarks() {
let mut bls_cache: BLSCache = BLSCache::default(); // 50000
assert_eq!(bls_cache.cache.len(), 0);
// benchmark at 100% cache hit rate
let mut pk_list: Vec<PublicKey> = [].to_vec();
let mut msg_list: Vec<&[u8]> = vec![];
let mut aggsig: Option<Signature> = None;
for i in 0..=25000 { //cache is half full
let byte_array: [u8; 32] = [i as u8; 32];
let sk: SecretKey = SecretKey::from_seed(&byte_array);
let pk: PublicKey = sk.public_key();
let msg: &[u8] = &[106; 32];
let sig: Signature = sign(&sk, msg);
pk_list.push(pk.clone());
msg_list.push(msg);
assert!(bls_cache.aggregate_verify([pk].iter(), [msg].iter(), &sig));
if aggsig.is_none() {aggsig = Some(sig);} else {aggsig = Some(aggregate([aggsig.unwrap(), sig]));}
}
let start = Instant::now();
assert!(bls_cache.aggregate_verify(pk_list.iter(), msg_list.iter(), &aggsig.clone().unwrap()));
let benchmark_1 = start.elapsed();
println!("Time elapsed in bls_cache.aggregate_verify() is: {:?}", benchmark_1);
let mut data = Vec::<(PublicKey, &[u8])>::new();
for (pk, msg) in pk_list.iter().zip(msg_list.iter()) {
data.push((pk.clone(), msg.as_ref()));
}
let full_aggsig = aggsig.clone().unwrap();

let start = Instant::now();
assert!(agg_ver(&aggsig.unwrap(), data.clone()));
let benchmark_2: Duration = start.elapsed();
println!("Time elapsed in agg_ver() is: {:?}", benchmark_2);
assert!(benchmark_1 < benchmark_2);

//benchmark at 50% cache hit
// reinstantiate the cache and re-cache half of the original setaggregate_verify
let mut bls_cache = BLSCache::default();
let mut aggsig: Option<Signature> = None;
for i in 0..=12500 {
let byte_array: [u8; 32] = [i as u8; 32];
let sk: SecretKey = SecretKey::from_seed(&byte_array);
let sig: Signature = sign(&sk, msg_list[i as usize]);
if aggsig.is_none() {aggsig = Some(sig.clone());} else {aggsig = Some(aggregate([aggsig.unwrap(), sig.clone()]));}
assert!(bls_cache.aggregate_verify([pk_list[i as usize].clone()].iter(), [msg_list[i as usize]].iter(), &sig));
}
let start = Instant::now();
assert!(bls_cache.aggregate_verify(pk_list.iter(), msg_list.iter(), &full_aggsig.clone()));
let benchmark_1 = start.elapsed();
println!("Time elapsed in bls_cache.aggregate_verify() is: {:?}", benchmark_1);
println!("Time elapsed in agg_ver() is: {:?}", benchmark_2);
assert!(benchmark_1 < benchmark_2);

//benchmark at 25% cache hit
// reinstantiate the cache and re-cache 25% of the original setaggregate_verify
let mut bls_cache = BLSCache::default();
let mut aggsig: Option<Signature> = None;
for i in 0..=6250 {
let byte_array: [u8; 32] = [i as u8; 32];
let sk: SecretKey = SecretKey::from_seed(&byte_array);
let sig: Signature = sign(&sk, msg_list[i as usize]);
if aggsig.is_none() {aggsig = Some(sig.clone());} else {aggsig = Some(aggregate([aggsig.unwrap(), sig.clone()]));}
assert!(bls_cache.aggregate_verify([pk_list[i as usize].clone()].iter(), [msg_list[i as usize]].iter(), &sig));
}
let start = Instant::now();
assert!(bls_cache.aggregate_verify(pk_list.iter(), msg_list.iter(), &full_aggsig.clone()));
let benchmark_1 = start.elapsed();
println!("Time elapsed in bls_cache.aggregate_verify() is: {:?}", benchmark_1);
println!("Time elapsed in agg_ver() is: {:?}", benchmark_2);
assert!(benchmark_1 < benchmark_2);

//benchmark at 0% cache hit
// reinstantiate the cache with no cached values
let mut bls_cache = BLSCache::default();
let start = Instant::now();
assert!(bls_cache.aggregate_verify(pk_list.iter(), msg_list.iter(), &full_aggsig.clone()));
let benchmark_1 = start.elapsed();
println!("Time elapsed in bls_cache.aggregate_verify() is: {:?}", benchmark_1);
println!("Time elapsed in agg_ver() is: {:?}", benchmark_2);
assert!(benchmark_1 < benchmark_2);


}
}

0 comments on commit 1c3c14b

Please sign in to comment.