Setup calibration for new and experimental cost types

soroban-env-host/benches/common/cost_types/bls12_381.rs

@@ -0,0 +1,312 @@
+use crate::common::HostCostMeasurement;
+use ark_bls12_381::{Fq, Fq2, Fr, G1Affine, G1Projective, G2Affine, G2Projective};
+use ark_ff::UniformRand;
+use ark_serialize::CanonicalSerialize;
+use rand::{rngs::StdRng, Rng, RngCore};
+use soroban_env_host::{
+    cost_runner::{
+        Bls12381DecodeFpRun, Bls12381DecodeFpSample, Bls12381EncodeFpRun, Bls12381EncodeFpSample,
+        Bls12381FrAddRun, Bls12381FrAddSubMulSample, Bls12381FrFromU256Run,
+        Bls12381FrFromU256Sample, Bls12381FrInvRun, Bls12381FrInvSample, Bls12381FrMulRun,
+        Bls12381FrPowRun, Bls12381FrPowSample, Bls12381FrSubRun, Bls12381FrToU256Run,
+        Bls12381FrToU256Sample, Bls12381G1AddRun, Bls12381G1AddSample, Bls12381G1MsmRun,
+        Bls12381G1MsmSample, Bls12381G1MulRun, Bls12381G1MulSample,
+        Bls12381G1ProjectiveToAffineRun, Bls12381G1ProjectiveToAffineSample, Bls12381G1ValidateRun,
+        Bls12381G1ValidateSample, Bls12381G2AddRun, Bls12381G2AddSample, Bls12381G2MsmRun,
+        Bls12381G2MsmSample, Bls12381G2MulRun, Bls12381G2MulSample,
+        Bls12381G2ProjectiveToAffineRun, Bls12381G2ProjectiveToAffineSample, Bls12381G2ValidateRun,
+        Bls12381G2ValidateSample, Bls12381HashToG1Run, Bls12381HashToG1Sample, Bls12381HashToG2Run,
+        Bls12381HashToG2Sample, Bls12381MapFp2ToG2Run, Bls12381MapFp2ToG2Sample,
+        Bls12381MapFpToG1Run, Bls12381MapFpToG1Sample, Bls12381PairingRun, Bls12381PairingSample,
+    },
+    xdr::ContractCostType,
+    Host, TryIntoVal, U256Val, U256,
+};
+
+pub(crate) struct Bls12381EncodeFpMeasure;
+impl HostCostMeasurement for Bls12381EncodeFpMeasure {
+    type Runner = Bls12381EncodeFpRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381EncodeFpSample {
+        let buf = vec![0; 1000];
+        let fp = Fq::rand(rng);
+        Bls12381EncodeFpSample(buf, fp)
+    }
+}
+pub(crate) struct Bls12381DecodeFpMeasure;
+impl HostCostMeasurement for Bls12381DecodeFpMeasure {
+    type Runner = Bls12381DecodeFpRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381DecodeFpSample {
+        let mut buf = vec![];
+        let _ = Fq::rand(rng).serialize_uncompressed(&mut buf).unwrap();
+        Bls12381DecodeFpSample(buf)
+    }
+}
+pub(crate) struct Bls12381G1ValidateMeasure;
+impl HostCostMeasurement for Bls12381G1ValidateMeasure {
+    type Runner = Bls12381G1ValidateRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381G1ValidateSample {
+        Bls12381G1ValidateSample(G1Affine::rand(rng), ContractCostType::Bls12381G1Validate)
+    }
+}
+pub(crate) struct Bls12381G2ValidateMeasure;
+impl HostCostMeasurement for Bls12381G2ValidateMeasure {
+    type Runner = Bls12381G2ValidateRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381G2ValidateSample {
+        Bls12381G2ValidateSample(G2Affine::rand(rng), ContractCostType::Bls12381G2Validate)
+    }
+}
+pub(crate) struct Bls12381FrFromU256Measure;
+impl HostCostMeasurement for Bls12381FrFromU256Measure {
+    type Runner = Bls12381FrFromU256Run;
+
+    fn new_random_case(host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381FrFromU256Sample {
+        let mut buf = [0; 32];
+        rng.fill_bytes(&mut buf);
+        let u = U256::from_be_bytes(buf);
+        let val: U256Val = u.try_into_val(host).unwrap();
+        Bls12381FrFromU256Sample(val)
+    }
+}
+pub(crate) struct Bls12381FrToU256Measure;
+impl HostCostMeasurement for Bls12381FrToU256Measure {
+    type Runner = Bls12381FrToU256Run;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381FrToU256Sample {
+        Bls12381FrToU256Sample(Fr::rand(rng))
+    }
+}
+pub(crate) struct Bls12381FrAddMeasure;
+impl HostCostMeasurement for Bls12381FrAddMeasure {
+    type Runner = Bls12381FrAddRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381FrAddSubMulSample {
+        Bls12381FrAddSubMulSample(Fr::rand(rng), Fr::rand(rng))
+    }
+}
+pub(crate) struct Bls12381FrSubMeasure;
+impl HostCostMeasurement for Bls12381FrSubMeasure {
+    type Runner = Bls12381FrSubRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381FrAddSubMulSample {
+        Bls12381FrAddSubMulSample(Fr::rand(rng), Fr::rand(rng))
+    }
+}
+pub(crate) struct Bls12381FrMulMeasure;
+impl HostCostMeasurement for Bls12381FrMulMeasure {
+    type Runner = Bls12381FrMulRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381FrAddSubMulSample {
+        Bls12381FrAddSubMulSample(Fr::rand(rng), Fr::rand(rng))
+    }
+}
+pub(crate) struct Bls12381FrPowMeasure;
+impl HostCostMeasurement for Bls12381FrPowMeasure {
+    type Runner = Bls12381FrPowRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, input: u64) -> Bls12381FrPowSample {
+        assert!(input <= 64);
+        let rhs = if input == 64 {
+            u64::MAX
+        } else {
+            (1 << input) - 1
+        };
+        Bls12381FrPowSample(Fr::rand(rng), rhs)
+    }
+}
+pub(crate) struct Bls12381FrInvMeasure;
+impl HostCostMeasurement for Bls12381FrInvMeasure {
+    type Runner = Bls12381FrInvRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381FrInvSample {
+        Bls12381FrInvSample(Fr::rand(rng))
+    }
+}
+
+pub(crate) struct Bls12381G1AddMeasure;
+
+impl HostCostMeasurement for Bls12381G1AddMeasure {
+    type Runner = Bls12381G1AddRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381G1AddSample {
+        let p0 = G1Affine::rand(rng);
+        let p1 = G1Affine::rand(rng);
+        Bls12381G1AddSample(p0, p1)
+    }
+}
+
+pub(crate) struct Bls12381G1ProjectiveToAffineMeasure;
+
+impl HostCostMeasurement for Bls12381G1ProjectiveToAffineMeasure {
+    type Runner = Bls12381G1ProjectiveToAffineRun;
+
+    fn new_random_case(
+        _host: &Host,
+        rng: &mut StdRng,
+        _input: u64,
+    ) -> Bls12381G1ProjectiveToAffineSample {
+        let p0 = G1Projective::rand(rng);
+        Bls12381G1ProjectiveToAffineSample(p0)
+    }
+}
+
+pub(crate) struct Bls12381G1MulMeasure;
+
+impl HostCostMeasurement for Bls12381G1MulMeasure {
+    type Runner = Bls12381G1MulRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381G1MulSample {
+        let p = G1Affine::rand(rng);
+        let s = Fr::rand(rng);
+        Bls12381G1MulSample(p, s)
+    }
+}
+
+pub(crate) struct Bls12381G1MsmMeasure;
+
+impl HostCostMeasurement for Bls12381G1MsmMeasure {
+    type Runner = Bls12381G1MsmRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, input: u64) -> Bls12381G1MsmSample {
+        Bls12381G1MsmSample(
+            (0..input)
+                .into_iter()
+                .map(|_| G1Affine::rand(rng))
+                .collect(),
+            (0..input).into_iter().map(|_| Fr::rand(rng)).collect(),
+        )
+    }
+}
+
+pub(crate) struct Bls12381MapFpToG1Measure;
+
+impl HostCostMeasurement for Bls12381MapFpToG1Measure {
+    type Runner = Bls12381MapFpToG1Run;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381MapFpToG1Sample {
+        let fp = Fq::rand(rng);
+        Bls12381MapFpToG1Sample(fp)
+    }
+}
+
+pub(crate) struct Bls12381HashToG1Measure;
+
+impl HostCostMeasurement for Bls12381HashToG1Measure {
+    type Runner = Bls12381HashToG1Run;
+    const STEP_SIZE: u64 = 64;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, input: u64) -> Bls12381HashToG1Sample {
+        let len = Self::INPUT_BASE_SIZE + input * Self::STEP_SIZE;
+        let domain = "SOROBAN-V01-CS01-with-BLS12381G1_XMD:SHA-256_SSWU_RO_"
+            .as_bytes()
+            .to_vec();
+        let mut msg = vec![0u8; len as usize];
+        rng.fill(msg.as_mut_slice());
+        Bls12381HashToG1Sample(domain, msg)
+    }
+}
+
+pub(crate) struct Bls12381G2ProjectiveToAffineMeasure;
+
+impl HostCostMeasurement for Bls12381G2ProjectiveToAffineMeasure {
+    type Runner = Bls12381G2ProjectiveToAffineRun;
+
+    fn new_random_case(
+        _host: &Host,
+        rng: &mut StdRng,
+        _input: u64,
+    ) -> Bls12381G2ProjectiveToAffineSample {
+        let p0 = G2Projective::rand(rng);
+        Bls12381G2ProjectiveToAffineSample(p0)
+    }
+}
+
+pub(crate) struct Bls12381G2AddMeasure;
+
+impl HostCostMeasurement for Bls12381G2AddMeasure {
+    type Runner = Bls12381G2AddRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381G2AddSample {
+        let p0 = G2Affine::rand(rng);
+        let p1 = G2Affine::rand(rng);
+        Bls12381G2AddSample(p0, p1)
+    }
+}
+
+pub(crate) struct Bls12381G2MulMeasure;
+
+impl HostCostMeasurement for Bls12381G2MulMeasure {
+    type Runner = Bls12381G2MulRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381G2MulSample {
+        let p = G2Affine::rand(rng);
+        let s = Fr::rand(rng);
+        Bls12381G2MulSample(p, s)
+    }
+}
+
+pub(crate) struct Bls12381G2MsmMeasure;
+
+impl HostCostMeasurement for Bls12381G2MsmMeasure {
+    type Runner = Bls12381G2MsmRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, input: u64) -> Bls12381G2MsmSample {
+        Bls12381G2MsmSample(
+            (0..input)
+                .into_iter()
+                .map(|_| G2Affine::rand(rng))
+                .collect(),
+            (0..input).into_iter().map(|_| Fr::rand(rng)).collect(),
+        )
+    }
+}
+
+pub(crate) struct Bls12381MapFp2ToG2Measure;
+
+impl HostCostMeasurement for Bls12381MapFp2ToG2Measure {
+    type Runner = Bls12381MapFp2ToG2Run;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Bls12381MapFp2ToG2Sample {
+        let fp2 = Fq2::rand(rng);
+        Bls12381MapFp2ToG2Sample(fp2)
+    }
+}
+
+pub(crate) struct Bls12381HashToG2Measure;
+
+impl HostCostMeasurement for Bls12381HashToG2Measure {
+    type Runner = Bls12381HashToG2Run;
+    const STEP_SIZE: u64 = 64;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, input: u64) -> Bls12381HashToG2Sample {
+        let len = Self::INPUT_BASE_SIZE + input * Self::STEP_SIZE;
+        let domain = "SOROBAN-V01-CS01-with-BLS12381G2_XMD:SHA-256_SSWU_RO_"
+            .as_bytes()
+            .to_vec();
+        let mut msg = vec![0u8; len as usize];
+        rng.fill(msg.as_mut_slice());
+        Bls12381HashToG2Sample(domain, msg)
+    }
+}
+
+pub(crate) struct Bls12381PairingMeasure;
+
+impl HostCostMeasurement for Bls12381PairingMeasure {
+    type Runner = Bls12381PairingRun;
+
+    fn new_random_case(_host: &Host, rng: &mut StdRng, input: u64) -> Bls12381PairingSample {
+        Bls12381PairingSample(
+            (0..input)
+                .into_iter()
+                .map(|_| G1Affine::rand(rng))
+                .collect(),
+            (0..input)
+                .into_iter()
+                .map(|_| G2Affine::rand(rng))
+                .collect(),
+        )
+    }
+}

soroban-env-host/benches/common/cost_types/mod.rs

@@ -1,3 +1,4 @@
+mod bls12_381;
 mod compute_ed25519_pubkey;
 mod compute_keccak256_hash;
 mod compute_sha256_hash;
@@ -18,6 +19,7 @@ mod visit_object;
 mod vm_ops;
 mod wasm_insn_exec;
 
+pub(crate) use bls12_381::*;
 pub(crate) use compute_ed25519_pubkey::*;
 pub(crate) use compute_keccak256_hash::*;
 pub(crate) use compute_sha256_hash::*;

soroban-env-host/benches/common/experimental/bls12_381.rs

@@ -0,0 +1,61 @@
+use crate::common::HostCostMeasurement;
+use ark_bls12_381::{Fq2, G1Affine, G2Affine};
+use ark_ff::UniformRand;
+use ark_serialize::CanonicalSerialize;
+use rand::rngs::StdRng;
+use soroban_env_host::{
+    cost_runner::{
+        Bls12381Fp2DeserializeUncompressedRun, Bls12381G1AffineDeserializeUncompressedRun,
+        Bls12381G1AffineSerializeUncompressedRun, Bls12381G2AffineDeserializeUncompressedRun,
+        Bls12381G2AffineSerializeUncompressedRun,
+    },
+    Host,
+};
+
+pub(crate) struct Bls12381G1AffineSerializeUncompressedMeasure;
+impl HostCostMeasurement for Bls12381G1AffineSerializeUncompressedMeasure {
+    type Runner = Bls12381G1AffineSerializeUncompressedRun;
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> G1Affine {
+        G1Affine::rand(rng)
+    }
+}
+pub(crate) struct Bls12381G2AffineSerializeUncompressedMeasure;
+impl HostCostMeasurement for Bls12381G2AffineSerializeUncompressedMeasure {
+    type Runner = Bls12381G2AffineSerializeUncompressedRun;
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> G2Affine {
+        G2Affine::rand(rng)
+    }
+}
+
+pub(crate) struct Bls12381G1AffineDeserializeUncompressedMeasure;
+impl HostCostMeasurement for Bls12381G1AffineDeserializeUncompressedMeasure {
+    type Runner = Bls12381G1AffineDeserializeUncompressedRun;
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Vec<u8> {
+        let mut buf = vec![];
+        let _ = G1Affine::rand(rng)
+            .serialize_uncompressed(&mut buf)
+            .unwrap();
+        buf
+    }
+}
+pub(crate) struct Bls12381G2AffineDeserializeUncompressedMeasure;
+impl HostCostMeasurement for Bls12381G2AffineDeserializeUncompressedMeasure {
+    type Runner = Bls12381G2AffineDeserializeUncompressedRun;
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Vec<u8> {
+        let mut buf = vec![];
+        let _ = G2Affine::rand(rng)
+            .serialize_uncompressed(&mut buf)
+            .unwrap();
+        buf
+    }
+}
+
+pub(crate) struct Bls12381Fp2DeserializeUncompressedMeasure;
+impl HostCostMeasurement for Bls12381Fp2DeserializeUncompressedMeasure {
+    type Runner = Bls12381Fp2DeserializeUncompressedRun;
+    fn new_random_case(_host: &Host, rng: &mut StdRng, _input: u64) -> Vec<u8> {
+        let mut buf = vec![];
+        let _ = Fq2::rand(rng).serialize_uncompressed(&mut buf).unwrap();
+        buf
+    }
+}