#![cfg_attr(windows, allow(dead_code))]
use cfg_if::cfg_if;
use iai::black_box;
#[cfg(feature = "experimental")]
use prio::{
codec::{Decode, Encode, ParameterizedDecode},
field::{Field255, FieldElement, FieldPrio2},
idpf::{Idpf, IdpfInput, IdpfPublicShare, RingBufferCache},
vdaf::{
poplar1::Poplar1IdpfValue,
prio2::{Prio2, Prio2PrepareShare},
xof::Seed,
Aggregator, Share,
},
};
use prio::{
field::{random_vector, Field128, Field64},
vdaf::{
prio3::{Prio3, Prio3InputShare},
Client,
},
};
fn prng(size: usize) -> Vec<Field128> {
random_vector(size).unwrap()
}
fn prng_16() -> Vec<Field128> {
prng(16)
}
fn prng_256() -> Vec<Field128> {
prng(256)
}
fn prng_1024() -> Vec<Field128> {
prng(1024)
}
fn prng_4096() -> Vec<Field128> {
prng(4096)
}
#[cfg(feature = "experimental")]
fn prio2_client(size: usize) -> Vec<Share<FieldPrio2, 32>> {
let prio2 = Prio2::new(size).unwrap();
let input = vec![0u32; size];
let nonce = [0; 16];
prio2.shard(&black_box(input), &black_box(nonce)).unwrap().1
}
#[cfg(feature = "experimental")]
fn prio2_client_10() -> Vec<Share<FieldPrio2, 32>> {
prio2_client(10)
}
#[cfg(feature = "experimental")]
fn prio2_client_100() -> Vec<Share<FieldPrio2, 32>> {
prio2_client(100)
}
#[cfg(feature = "experimental")]
fn prio2_client_1000() -> Vec<Share<FieldPrio2, 32>> {
prio2_client(1000)
}
#[cfg(feature = "experimental")]
fn prio2_shard_and_prepare(size: usize) -> Prio2PrepareShare {
let prio2 = Prio2::new(size).unwrap();
let input = vec![0u32; size];
let nonce = [0; 16];
let (public_share, input_shares) = prio2.shard(&black_box(input), &black_box(nonce)).unwrap();
prio2
.prepare_init(&[0; 32], 0, &(), &nonce, &public_share, &input_shares[0])
.unwrap()
.1
}
#[cfg(feature = "experimental")]
fn prio2_shard_and_prepare_10() -> Prio2PrepareShare {
prio2_shard_and_prepare(10)
}
#[cfg(feature = "experimental")]
fn prio2_shard_and_prepare_100() -> Prio2PrepareShare {
prio2_shard_and_prepare(100)
}
#[cfg(feature = "experimental")]
fn prio2_shard_and_prepare_1000() -> Prio2PrepareShare {
prio2_shard_and_prepare(1000)
}
fn prio3_client_count() -> Vec<Prio3InputShare<Field64, 16>> {
let prio3 = Prio3::new_count(2).unwrap();
let measurement = true;
let nonce = [0; 16];
prio3
.shard(&black_box(measurement), &black_box(nonce))
.unwrap()
.1
}
fn prio3_client_histogram_10() -> Vec<Prio3InputShare<Field128, 16>> {
let prio3 = Prio3::new_histogram(2, 10, 3).unwrap();
let measurement = 9;
let nonce = [0; 16];
prio3
.shard(&black_box(measurement), &black_box(nonce))
.unwrap()
.1
}
fn prio3_client_sum_32() -> Vec<Prio3InputShare<Field128, 16>> {
let prio3 = Prio3::new_sum(2, 16).unwrap();
let measurement = 1337;
let nonce = [0; 16];
prio3
.shard(&black_box(measurement), &black_box(nonce))
.unwrap()
.1
}
fn prio3_client_count_vec_1000() -> Vec<Prio3InputShare<Field128, 16>> {
let len = 1000;
let prio3 = Prio3::new_sum_vec(2, 1, len, 31).unwrap();
let measurement = vec![0; len];
let nonce = [0; 16];
prio3
.shard(&black_box(measurement), &black_box(nonce))
.unwrap()
.1
}
#[cfg(feature = "multithreaded")]
fn prio3_client_count_vec_multithreaded_1000() -> Vec<Prio3InputShare<Field128, 16>> {
let len = 1000;
let prio3 = Prio3::new_sum_vec_multithreaded(2, 1, len, 31).unwrap();
let measurement = vec![0; len];
let nonce = [0; 16];
prio3
.shard(&black_box(measurement), &black_box(nonce))
.unwrap()
.1
}
#[cfg(feature = "experimental")]
fn idpf_poplar_gen(
input: &IdpfInput,
inner_values: Vec<Poplar1IdpfValue<Field64>>,
leaf_value: Poplar1IdpfValue<Field255>,
) {
let idpf = Idpf::new((), ());
idpf.gen(input, inner_values, leaf_value, &[0; 16]).unwrap();
}
#[cfg(feature = "experimental")]
fn idpf_poplar_gen_8() {
let input = IdpfInput::from_bytes(b"A");
let one = Field64::one();
idpf_poplar_gen(
&input,
vec![Poplar1IdpfValue::new([one, one]); 7],
Poplar1IdpfValue::new([Field255::one(), Field255::one()]),
);
}
#[cfg(feature = "experimental")]
fn idpf_poplar_gen_128() {
let input = IdpfInput::from_bytes(b"AAAAAAAAAAAAAAAA");
let one = Field64::one();
idpf_poplar_gen(
&input,
vec![Poplar1IdpfValue::new([one, one]); 127],
Poplar1IdpfValue::new([Field255::one(), Field255::one()]),
);
}
#[cfg(feature = "experimental")]
fn idpf_poplar_gen_2048() {
let input = IdpfInput::from_bytes(&[0x41; 256]);
let one = Field64::one();
idpf_poplar_gen(
&input,
vec![Poplar1IdpfValue::new([one, one]); 2047],
Poplar1IdpfValue::new([Field255::one(), Field255::one()]),
);
}
#[cfg(feature = "experimental")]
fn idpf_poplar_eval(
input: &IdpfInput,
public_share: &IdpfPublicShare<Poplar1IdpfValue<Field64>, Poplar1IdpfValue<Field255>>,
key: &Seed<16>,
) {
let mut cache = RingBufferCache::new(1);
let idpf = Idpf::new((), ());
idpf.eval(0, public_share, key, input, &[0; 16], &mut cache)
.unwrap();
}
#[cfg(feature = "experimental")]
fn idpf_poplar_eval_8() {
let input = IdpfInput::from_bytes(b"A");
let public_share = IdpfPublicShare::get_decoded_with_param(&8, &[0x7f; 306]).unwrap();
let key = Seed::get_decoded(&[0xff; 16]).unwrap();
idpf_poplar_eval(&input, &public_share, &key);
}
#[cfg(feature = "experimental")]
fn idpf_poplar_eval_128() {
let input = IdpfInput::from_bytes(b"AAAAAAAAAAAAAAAA");
let public_share = IdpfPublicShare::get_decoded_with_param(&128, &[0x7f; 4176]).unwrap();
let key = Seed::get_decoded(&[0xff; 16]).unwrap();
idpf_poplar_eval(&input, &public_share, &key);
}
#[cfg(feature = "experimental")]
fn idpf_poplar_eval_2048() {
let input = IdpfInput::from_bytes(&[0x41; 256]);
let public_share = IdpfPublicShare::get_decoded_with_param(&2048, &[0x7f; 66096]).unwrap();
let key = Seed::get_decoded(&[0xff; 16]).unwrap();
idpf_poplar_eval(&input, &public_share, &key);
}
#[cfg(feature = "experimental")]
fn idpf_codec() {
let data = hex::decode(concat!(
"9a",
"0000000000000000000000000000000000000000000000",
"01eb3a1bd6b5fa4a4500000000000000000000000000000000",
"ffffffff0000000022522c3fd5a33cac00000000000000000000000000000000",
"ffffffff0000000069f41eee46542b6900000000000000000000000000000000",
"00000000000000000000000000000000000000000000000000000000000000",
"017d1fd6df94280145a0dcc933ceb706e9219d50e7c4f92fd8ca9a0ffb7d819646",
))
.unwrap();
let bits = 4;
let public_share = IdpfPublicShare::<Poplar1IdpfValue<Field64>, Poplar1IdpfValue<Field25
5>>::get_decoded_with_param(&bits, &data).unwrap();
let encoded = public_share.get_encoded().unwrap();
let _ = black_box(encoded.len());
}
macro_rules! main_base {
( $( $func_name:ident ),* $(,)* ) => {
iai::main!(
prng_16,
prng_256,
prng_1024,
prng_4096,
prio3_client_count,
prio3_client_histogram_10,
prio3_client_sum_32,
prio3_client_count_vec_1000,
$( $func_name, )*
);
};
}
#[cfg(feature = "multithreaded")]
macro_rules! main_add_multithreaded {
( $( $func_name:ident ),* $(,)* ) => {
main_base!(
prio3_client_count_vec_multithreaded_1000,
$( $func_name, )*
);
};
}
#[cfg(not(feature = "multithreaded"))]
macro_rules! main_add_multithreaded {
( $( $func_name:ident ),* $(,)* ) => {
main_base!(
$( $func_name, )*
);
};
}
#[cfg(feature = "experimental")]
macro_rules! main_add_experimental {
( $( $func_name:ident ),* $(,)* ) => {
main_add_multithreaded!(
prio2_client_10,
prio2_client_100,
prio2_client_1000,
prio2_shard_and_prepare_10,
prio2_shard_and_prepare_100,
prio2_shard_and_prepare_1000,
idpf_codec,
idpf_poplar_gen_8,
idpf_poplar_gen_128,
idpf_poplar_gen_2048,
idpf_poplar_eval_8,
idpf_poplar_eval_128,
idpf_poplar_eval_2048,
$( $func_name, )*
);
};
}
#[cfg(not(feature = "experimental"))]
macro_rules! main_add_experimental {
( $( $func_name:ident ),* $(,)* ) => {
main_add_multithreaded!(
$( $func_name, )*
);
};
}
cfg_if! {
if #[cfg(windows)] {
fn main() {
eprintln!("Cycle count benchmarks are not supported on Windows.");
}
}
else {
main_add_experimental!();
}
}
