Add gas parameters for event validation + calibration harnesses. (#1635)

Co-authored-by: Steven Allen <steven@stebalien.com>

Author: raulk

fvm/Cargo.toml

@@ -69,3 +69,4 @@ testing = []
 arb = ["arbitrary", "quickcheck"]
 m2-native = []
 hyperspace = []
+gas_calibration = []

fvm/src/gas/price_list.rs

@@ -269,13 +269,25 @@ lazy_static! {
             memory_fill_per_byte_cost: Gas::from_milligas(400),
         },
 
-        // TODO::PARAM
+        // These parameters are specifically sized for EVM events. They will need
+        // to be revisited before Wasm actors are able to emit arbitrary events.
+        //
+        // Validation costs are dependent on encoded length, but also
+        // co-dependent on the number of entries. The latter is a chicken-and-egg
+        // situation because we can only learn how many entries were emitted once we
+        // decode the CBOR event.
+        //
+        // We will likely need to revisit the ABI of emit_event to remove CBOR
+        // as the exchange format.
         event_validation_cost: ScalingCost {
-            flat: Zero::zero(),
-            scale: Zero::zero(),
+            flat: Gas::new(1750),
+            scale: Gas::new(25),
         },
 
-        // TODO::PARAM
+        // The protocol does not currently mandate indexing work, so these are
+        // left at zero. Once we start populating and committing indexing data
+        // structures, these costs will need to reflect the computation and
+        // storage costs of such actions.
         event_accept_per_index_element: ScalingCost {
             flat: Zero::zero(),
             scale: Zero::zero(),
@@ -890,19 +902,33 @@ impl PriceList {
             }
         }
 
-        // The estimated size of the serialized StampedEvent event, which includes the ActorEvent
-        // + 8 bytes for the actor ID + some bytes for CBOR framing.
+        // The estimated size of the serialized StampedEvent event, which
+        // includes the ActorEvent + 8 bytes for the actor ID + some bytes
+        // for CBOR framing.
         const STAMP_EXTRA_SIZE: usize = 12;
         let stamped_event_size = serialized_len + STAMP_EXTRA_SIZE;
 
+        // Charge for 3 memory copy operations.
+        // This includes the cost of forming a StampedEvent, copying into the
+        // AMT's buffer on finish, and returning to the client.
         let memcpy = self.block_memcpy.apply(stamped_event_size);
+
+        // Charge for 2 memory allocations.
+        // This includes the cost of retaining the StampedEvent in the call manager,
+        // and allocaing into the AMT's buffer on finish.
         let alloc = self.block_allocate.apply(stamped_event_size);
 
+        // Charge for the hashing on AMT insertion.
+        let hash = self.hashing_cost[&SupportedHashes::Blake2b256].apply(stamped_event_size);
+
         GasCharge::new(
             "OnActorEventAccept",
-            (memcpy * 3u32) + alloc,
+            memcpy + alloc,
             self.event_accept_per_index_element.flat * indexed_elements
-                + self.event_accept_per_index_element.scale * indexed_bytes,
+                + self.event_accept_per_index_element.scale * indexed_bytes
+                + memcpy * 2u32 // deferred cost, placing here to hide from benchmark
+                + alloc // deferred cost, placing here to hide from benchmark
+                + hash, // deferred cost, placing here to hide from benchmark
         )
     }
 }

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)
 }

shared/src/event/mod.rs

@@ -12,9 +12,9 @@ use crate::ActorID;
 #[derive(Serialize_tuple, Deserialize_tuple, PartialEq, Eq, Clone, Debug)]
 pub struct StampedEvent {
     /// Carries the ID of the actor that emitted this event.
-    emitter: ActorID,
+    pub emitter: ActorID,
     /// The event as emitted by the actor.
-    event: ActorEvent,
+    pub event: ActorEvent,
 }
 
 impl StampedEvent {

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

@@ -2,14 +2,15 @@
 // 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 +36,8 @@ pub enum Method {
     OnRecoverSecpPublicKey,
     /// Measure sends
     OnSend,
+    /// Emit events, driven by the selected mode. See EventCalibrationMode for more info.
+    OnEvent,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -76,6 +79,25 @@ pub struct OnRecoverSecpPublicKeyParams {
     pub seed: u64,
 }
 
+#[derive(Serialize, Deserialize)]
+pub enum EventCalibrationMode {
+    /// Produce events with the specified shape.
+    Shape((usize, usize, usize)),
+    /// Attempt to reach a target size for the CBOR event.
+    TargetSize(usize),
+}
+
+#[derive(Serialize, Deserialize)]
+pub struct OnEventParams {
+    pub iterations: usize,
+    pub mode: EventCalibrationMode,
+    /// Number of entries in the event.
+    pub entries: usize,
+    /// Flags to apply to all entries.
+    pub flags: Flags,
+    pub seed: u64,
+}
+
 #[derive(Serialize, Deserialize)]
 pub struct OnSendParams {
     pub iterations: usize,
@@ -125,6 +147,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),
     }
 }
 
@@ -231,6 +254,75 @@ fn on_send(p: OnSendParams) -> Result<()> {
     Ok(())
 }
 
+fn on_event(p: OnEventParams) -> Result<()> {
+    match p.mode {
+        EventCalibrationMode::Shape(_) => on_event_shape(p),
+        EventCalibrationMode::TargetSize(_) => on_event_target_size(p),
+    }
+}
+
+fn on_event_shape(p: OnEventParams) -> Result<()> {
+    let EventCalibrationMode::Shape((key_size, value_size, last_value_size)) = p.mode else { panic!() };
+    let mut value = vec![0; value_size];
+    let mut last_value = vec![0; last_value_size];
+
+    for i in 0..p.iterations {
+        random_mutations(&mut value, p.seed + i as u64, MUTATION_COUNT);
+        let key = random_ascii_string(key_size, p.seed + p.iterations as u64 + i as u64); // non-overlapping seed
+        let mut entries: Vec<Entry> = std::iter::repeat_with(|| Entry {
+            flags: p.flags,
+            key: key.clone(),
+            value: value.clone().into(),
+        })
+        .take(p.entries - 1)
+        .collect();
+
+        random_mutations(&mut last_value, p.seed + i as u64, MUTATION_COUNT);
+        entries.push(Entry {
+            flags: p.flags,
+            key,
+            value: last_value.clone().into(),
+        });
+
+        fvm_sdk::event::emit_event(&ActorEvent::from(entries))?;
+    }
+
+    Ok(())
+}
+
+fn on_event_target_size(p: OnEventParams) -> Result<()> {
+    let EventCalibrationMode::TargetSize(target_size) = p.mode else { panic!() };
+
+    // 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 = ((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 random_bytes(size: usize, seed: u64) -> Vec<u8> {
     lcg8(seed).take(size).collect()
 }
@@ -244,13 +336,21 @@ 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> {
-    let a = 6364136223846793005;
-    let c = 1442695040888963407;
+fn lcg64(initial_seed: u64) -> impl Iterator<Item = u64> {
+    let a = 6364136223846793005_u64;
+    let c = 1442695040888963407_u64;
+    let mut seed = initial_seed;
     std::iter::repeat_with(move || {
-        seed = a * seed + c;
+        seed = a.wrapping_mul(seed).wrapping_add(c);
         seed
     })
 }

testing/calibration/measurements/out/charts/charges/OnActorEventAccept.png

@@ -0,0 +1,5 @@
+{"label":"1entries","intercept":22.313744711945862,"slope":0.0003946919167965678,"r_squared":0.01663829416736118}
+{"label":"2entries","intercept":23.856545416096417,"slope":-0.0001249874126324024,"r_squared":0.0027511896009608794}
+{"label":"3entries","intercept":24.14099858063833,"slope":0.00025360607685473695,"r_squared":0.012103391403471941}
+{"label":"4entries","intercept":24.50200090218209,"slope":0.00026462487974013456,"r_squared":0.013041913153861495}
+{"label":"5entries","intercept":23.807326324824327,"slope":0.0003651319991397078,"r_squared":0.0241200673621067}

testing/calibration/measurements/out/charts/charges/OnActorEventValidate.png

@@ -0,0 +1,5 @@
+{"label":"1entries","intercept":219.3512815076574,"slope":0.025264402585468613,"r_squared":0.6969932172786232}
+{"label":"2entries","intercept":326.8452955079036,"slope":0.03197752325924088,"r_squared":0.6690516332666083}
+{"label":"3entries","intercept":442.6102960119082,"slope":0.02837213671866441,"r_squared":0.539347916250855}
+{"label":"4entries","intercept":548.9627365822935,"slope":0.029499917871311416,"r_squared":0.4811866768000761}
+{"label":"5entries","intercept":658.950925843136,"slope":0.030171458910286723,"r_squared":0.4922891005837865}

testing/calibration/measurements/out/charts/overall.png

@@ -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],