add gas calibration harness for events.

Author: raulk

fvm/src/kernel/default.rs

@@ -985,18 +985,20 @@ where
             .call_manager
             .charge_gas(self.call_manager.price_list().on_actor_event_validate(len))?;
 
-        let actor_evt = match panic::catch_unwind(|| {
-            fvm_ipld_encoding::from_slice(raw_evt).or_error(ErrorNumber::IllegalArgument)
-        }) {
-            Ok(v) => v,
-            Err(e) => {
-                log::error!("panic when decoding cbor from actor: {:?}", e);
-                Err(syscall_error!(IllegalArgument; "panic when decoding cbor from actor").into())
-            }
+        let actor_evt = {
+            let res = match panic::catch_unwind(|| {
+                fvm_ipld_encoding::from_slice(raw_evt).or_error(ErrorNumber::IllegalArgument)
+            }) {
+                Ok(v) => v,
+                Err(e) => {
+                    log::error!("panic when decoding event cbor from actor: {:?}", e);
+                    Err(syscall_error!(IllegalArgument; "panic when decoding event cbor from actor").into())
+                }
+            };
+            t.stop();
+            res
         }?;
 
-        t.stop();
-
         let t = self.call_manager.charge_gas(
             self.call_manager
                 .price_list()

fvm/src/syscalls/event.rs

@@ -18,6 +18,15 @@ pub fn emit_event(
     event_off: u32, // ActorEvent
     event_len: u32,
 ) -> Result<()> {
+    // Disable the limits for gas calibration.
+    #[cfg(not(feature = "gas_calibration"))]
+    {
+        const MAX_CBOR_EVENT_LEN: u32 = 1024;
+        if event_len > MAX_CBOR_EVENT_LEN {
+            return Err(crate::syscall_error!(IllegalArgument; "exceeded maximum event length ({} bytes); got {}", MAX_CBOR_EVENT_LEN, event_len).into());
+        }
+    }
+
     let raw = context.memory.try_slice(event_off, event_len)?;
     context.kernel.emit_event(raw)
 }

testing/calibration/Cargo.toml

@@ -8,7 +8,7 @@ authors = ["Protocol Labs", "Filecoin Core Devs"]
 repository = "https://github.com/filecoin-project/ref-fvm"
 
 [dependencies]
-fvm = { version = "3.0.0-alpha.22", path = "../../fvm", default-features = false, features = ["testing"] }
+fvm = { version = "3.0.0-alpha.22", path = "../../fvm", default-features = false, features = ["testing", "gas_calibration"] }
 fvm_shared = { version = "3.0.0-alpha.18", path = "../../shared", features = ["testing"] }
 fvm_ipld_car = { version = "0.6.0", path = "../../ipld/car" }
 fvm_ipld_blockstore = { version = "0.1.1", path = "../../ipld/blockstore" }

testing/calibration/README.md

@@ -19,7 +19,7 @@ The calibration uses the machinery from the integration tests, but it's kept sep
 
 Note that the `--release` flag has a huge impact on runtimes and therefore the model paramters, in the order of 100x.
 
-Alternatively all the scenarios and exports can be executed the followign way:
+Alternatively all the scenarios and exports can be executed the following way:
 
 ```shell
 make run

testing/calibration/contract/fil-gas-calibration-actor/src/lib.rs

@@ -1,15 +1,18 @@
+use std::num::Wrapping;
+
 // Copyright 2021-2023 Protocol Labs
 // SPDX-License-Identifier: Apache-2.0, MIT
 use anyhow::{anyhow, Result};
 use cid::multihash::Code;
-use fvm_ipld_encoding::DAG_CBOR;
+use fvm_ipld_encoding::{RawBytes, DAG_CBOR};
 use fvm_sdk::message::params_raw;
 use fvm_sdk::vm::abort;
 use fvm_shared::address::{Address, Protocol};
 use fvm_shared::crypto::hash::SupportedHashes;
 use fvm_shared::crypto::signature::{Signature, SignatureType, SECP_SIG_LEN};
 use fvm_shared::econ::TokenAmount;
 use fvm_shared::error::ExitCode;
+use fvm_shared::event::{ActorEvent, Entry, Flags};
 use fvm_shared::sys::SendFlags;
 use num_derive::FromPrimitive;
 use num_traits::FromPrimitive;
@@ -35,6 +38,8 @@ pub enum Method {
     OnRecoverSecpPublicKey,
     /// Measure sends
     OnSend,
+    /// Emit events variying the number of entries, and with variable lengths for keys and values.
+    OnEvent,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -76,6 +81,18 @@ pub struct OnRecoverSecpPublicKeyParams {
     pub seed: u64,
 }
 
+#[derive(Serialize, Deserialize)]
+pub struct OnEventParams {
+    pub iterations: usize,
+    /// Number of entries in the event.
+    pub entries: usize,
+    /// Target size of the CBOR object.
+    pub target_size: usize,
+    /// Flags to apply to all entries.
+    pub flags: Flags,
+    pub seed: u64,
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct OnSendParams {
     pub iterations: usize,
@@ -125,6 +142,7 @@ fn dispatch(method: Method, params_ptr: u32) -> Result<()> {
         Method::OnVerifySignature => dispatch_to(on_verify_signature, params_ptr),
         Method::OnRecoverSecpPublicKey => dispatch_to(on_recover_secp_public_key, params_ptr),
         Method::OnSend => dispatch_to(on_send, params_ptr),
+        Method::OnEvent => dispatch_to(on_event, params_ptr),
     }
 }
 
@@ -193,6 +211,38 @@ fn on_verify_signature(p: OnVerifySignatureParams) -> Result<()> {
     Ok(())
 }
 
+fn on_event(p: OnEventParams) -> Result<()> {
+    // Deduct the approximate overhead of each entry (3 bytes) + flag (1 byte). This
+    // is fuzzy because the size of the encoded CBOR depends on the length of fields, but it's good enough.
+    let size_per_entry =
+        ((p.target_size.checked_sub(p.entries * 4).unwrap_or(1)) / p.entries).max(1);
+    let mut rand = lcg64(p.seed);
+    for _ in 0..p.iterations {
+        let mut entries = Vec::with_capacity(p.entries);
+        for _ in 0..p.entries {
+            let (r1, r2, r3) = (
+                rand.next().unwrap(),
+                rand.next().unwrap(),
+                rand.next().unwrap(),
+            );
+            // Generate a random key of an arbitrary length that fits within the size per entry.
+            // This will never be equal to size_per_entry, and it might be zero, which is fine
+            // for gas calculation purposes.
+            let key = random_ascii_string((r1 % size_per_entry as u64) as usize, r2);
+            // Generate a value to fill up the remaining bytes.
+            let value = random_bytes(size_per_entry - key.len(), r3);
+            entries.push(Entry {
+                flags: p.flags,
+                key,
+                value: RawBytes::from(value),
+            })
+        }
+        fvm_sdk::event::emit_event(&ActorEvent::from(entries))?;
+    }
+
+    Ok(())
+}
+
 fn on_recover_secp_public_key(p: OnRecoverSecpPublicKeyParams) -> Result<()> {
     let mut data = random_bytes(p.size, p.seed);
     let sig: [u8; SECP_SIG_LEN] = p
@@ -244,14 +294,22 @@ fn random_mutations(data: &mut Vec<u8>, seed: u64, n: usize) {
     }
 }
 
+/// Generates a random string in the 0x20 - 0x7e ASCII character range
+/// (alphanumeric + symbols, excluding the delete symbol).
+fn random_ascii_string(n: usize, seed: u64) -> String {
+    let bytes = lcg64(seed).map(|x| ((x % 95) + 32) as u8).take(n).collect();
+    String::from_utf8(bytes).unwrap()
+}
+
 /// Knuth's quick and dirty random number generator.
 /// https://en.wikipedia.org/wiki/Linear_congruential_generator
-fn lcg64(mut seed: u64) -> impl Iterator<Item = u64> {
+fn lcg64(initial_seed: u64) -> impl Iterator<Item = u64> {
     let a = 6364136223846793005;
     let c = 1442695040888963407;
+    let mut seed = Wrapping(initial_seed);
     std::iter::repeat_with(move || {
-        seed = a * seed + c;
-        seed
+        seed = Wrapping(a) * seed + Wrapping(c);
+        seed.0
     })
 }
 

testing/calibration/src/bin/on_block.rs

@@ -47,6 +47,7 @@ fn main() {
                 if charge.name.starts_with("OnBlock") {
                     if let Some(t) = charge.elapsed.get() {
                         let ob = Obs {
+                            charge: charge.name.to_string(),
                             label: "n/a".into(),
                             elapsed_nanos: t.as_nanos(),
                             variables: vec![*size],

testing/calibration/src/bin/on_event.rs

@@ -0,0 +1,77 @@
+// Copyright 2021-2023 Protocol Labs
+// SPDX-License-Identifier: Apache-2.0, MIT
+#![feature(slice_group_by)]
+
+use std::usize;
+
+use fil_gas_calibration_actor::{Method, OnEventParams};
+use fvm_gas_calibration::*;
+use fvm_shared::event::Flags;
+use rand::{thread_rng, Rng};
+
+const CHARGE_VALIDATE: &str = "OnActorEventValidate";
+const CHARGE_ACCEPT: &str = "OnActorEventAccept";
+const METHOD: Method = Method::OnEvent;
+
+fn main() {
+    let mut config: Vec<(usize, usize)> = vec![];
+    // 1 entry, ranging 8..1024 bytes
+    config.extend((3u32..=10).map(|n| (1usize, u64::pow(2, n) as usize)));
+    // 2 entry, ranging 16..1024 bytes
+    config.extend((4u32..=10).map(|n| (2usize, u64::pow(2, n) as usize)));
+    // 4 entries, ranging 32..1024 bytes
+    config.extend((5u32..=10).map(|n| (4usize, u64::pow(2, n) as usize)));
+    // 8 entries, ranging 64..1024 bytes
+    config.extend((6u32..=10).map(|n| (8usize, u64::pow(2, n) as usize)));
+    // 16 entries, ranging 128..1024 bytes
+    config.extend((7u32..=10).map(|n| (16usize, u64::pow(2, n) as usize)));
+    // 32 entries, ranging 256..1024 bytes
+    config.extend((8u32..=10).map(|n| (32usize, u64::pow(2, n) as usize)));
+    // 64 entries, ranging 512..1024 bytes
+    config.extend((9u32..=10).map(|n| (64usize, u64::pow(2, n) as usize)));
+
+    let iterations = 500;
+
+    let (mut validate_obs, mut accept_obs) = (Vec::new(), Vec::new());
+
+    let mut te = instantiate_tester();
+
+    let mut rng = thread_rng();
+
+    for (entries, target_size) in config.iter() {
+        let label = format!("{entries:?}entries");
+        let params = OnEventParams {
+            iterations,
+            // number of entries to emit
+            entries: *entries,
+            // target size of the encoded CBOR; this is approximate.
+            target_size: *target_size,
+            flags: Flags::FLAG_INDEXED_ALL,
+            seed: rng.gen(),
+        };
+
+        let ret = te.execute_or_die(METHOD as u64, &params);
+
+        {
+            let mut series =
+                collect_obs(ret.clone(), CHARGE_VALIDATE, &label, *target_size as usize);
+            series = eliminate_outliers(series, 0.02, Eliminate::Top);
+            validate_obs.extend(series);
+        };
+
+        {
+            let mut series = collect_obs(ret.clone(), CHARGE_ACCEPT, &label, *target_size as usize);
+            series = eliminate_outliers(series, 0.02, Eliminate::Top);
+            accept_obs.extend(series);
+        };
+    }
+
+    for (obs, name) in vec![(validate_obs, CHARGE_VALIDATE), (accept_obs, CHARGE_ACCEPT)].iter() {
+        let regression = obs
+            .group_by(|a, b| a.label == b.label)
+            .map(|g| least_squares(g[0].label.to_owned(), g, 0))
+            .collect::<Vec<_>>();
+
+        export(name, &obs, &regression).unwrap();
+    }
+}

testing/calibration/src/lib.rs

@@ -24,7 +24,7 @@ use num_traits::Zero;
 use serde::Serialize;
 
 pub const WASM_COMPILED_PATH: &str =
-    "../../target/debug/wbuild/fil_gas_calibration_actor/fil_gas_calibration_actor.compact.wasm";
+    "../../target/release/wbuild/fil_gas_calibration_actor/fil_gas_calibration_actor.compact.wasm";
 
 pub const ENOUGH_GAS: Gas = Gas::new(1_000_000_000);
 
@@ -88,6 +88,7 @@ lazy_static! {
 /// to model time in terms of some variables.
 #[derive(Serialize)]
 pub struct Obs {
+    pub charge: String,
     pub label: String,
     pub elapsed_nanos: u128,
     pub variables: Vec<usize>,
@@ -257,6 +258,7 @@ pub fn collect_obs(ret: &ApplyRet, name: &str, label: &str, size: usize) -> Vec<
         .iter()
         .filter_map(|t| match t {
             ExecutionEvent::GasCharge(charge) if charge.name == name => Some(Obs {
+                charge: charge.name.to_string(),
                 label: label.to_owned(),
                 elapsed_nanos: charge.elapsed.get().unwrap().as_nanos(),
                 variables: vec![size],