refactor(protocol/sandbox): remove store clear counter

Cargo.toml

@@ -180,6 +180,7 @@ primitive-types = { version = "0.12.2", default-features = false }
 proc-macro2 = { version = "1", default-features = false }
 prometheus = { version = "0.14.0", default-features = false }
 proptest = "1.5.0"
+criterion = { version = "0.7", features = ["html_reports"] }
 quick-xml = "0.28"
 quote = { version = "1.0.36", default-features = false }
 rand = { version = "0.8", default-features = false }

protocol/sandbox/host/Cargo.toml

@@ -30,6 +30,13 @@ region.workspace = true
 
 gear-workspace-hack.workspace = true
 
+[dev-dependencies]
+criterion.workspace = true
+
 [features]
 # See wasmi/extra-checks for more information.
 wasmi-extra-checks = ["wasmi/extra-checks"]
+
+[[bench]]
+name = "wasmtime_store_growth"
+harness = false

protocol/sandbox/host/benches/wasmtime_store_growth.rs

@@ -0,0 +1,157 @@
+// Copyright (C) Gear Technologies Inc.
+// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
+
+use criterion::{Criterion, criterion_group, criterion_main};
+use gear_sandbox_env::{EnvironmentDefinition, Instantiate};
+use gear_sandbox_host::{
+    context::{HostResult, SupervisorContext, SupervisorContextDispatcher, SupervisorFuncIndex},
+    sandbox::{GuestEnvironment, SandboxBackend, SandboxComponents},
+};
+use parity_scale_codec::Encode;
+use sp_wasm_interface_common::{Pointer, WordSize};
+use std::{
+    hint::black_box,
+    time::{Duration, Instant},
+};
+
+const EMPTY_WASM: &[u8] = b"\0asm\x01\0\0\0";
+const MAX_OPERATIONS_PER_STORE: u64 =
+    (wasmtime::DEFAULT_INSTANCE_LIMIT as u64 + wasmtime::DEFAULT_MEMORY_LIMIT as u64) / 2;
+
+#[derive(Clone, Copy)]
+enum ResetPolicy {
+    Never,
+    Every(usize),
+}
+
+impl ResetPolicy {
+    fn as_str(self) -> &'static str {
+        match self {
+            Self::Never => "long_lived_store",
+            Self::Every(_) => "clear_periodically",
+        }
+    }
+}
+
+struct NoopSupervisor;
+
+impl SupervisorContext for NoopSupervisor {
+    fn data_ptr(&self) -> *const () {
+        self as *const _ as *const ()
+    }
+
+    fn read_memory_into(
+        &self,
+        _address: Pointer<u8>,
+        dest: &mut [u8],
+    ) -> std::result::Result<(), String> {
+        dest.fill(0);
+        Ok(())
+    }
+
+    fn write_memory(
+        &mut self,
+        _address: Pointer<u8>,
+        _data: &[u8],
+    ) -> std::result::Result<(), String> {
+        Ok(())
+    }
+
+    fn allocate_memory(&mut self, _size: WordSize) -> std::result::Result<Pointer<u8>, String> {
+        Ok(Pointer::null())
+    }
+
+    fn deallocate_memory(&mut self, _ptr: Pointer<u8>) -> std::result::Result<(), String> {
+        Ok(())
+    }
+}
+
+impl SupervisorContextDispatcher for NoopSupervisor {
+    fn dispatch_thunk_id(&self) -> u32 {
+        0
+    }
+
+    fn invoke(
+        &mut self,
+        _invoke_args_ptr: Pointer<u8>,
+        _invoke_args_len: WordSize,
+        _func_idx: SupervisorFuncIndex,
+    ) -> HostResult<i64> {
+        Ok(0)
+    }
+}
+
+fn bench_wasmtime_store_growth(c: &mut Criterion) {
+    let mut group = c.benchmark_group("wasmtime_store_growth");
+
+    for reset_policy in [ResetPolicy::Never, ResetPolicy::Every(50)] {
+        group.bench_function(reset_policy.as_str(), |b| {
+            b.iter_custom(|iters| {
+                let mut state = BenchState::new();
+                let mut elapsed = Duration::ZERO;
+                for i in 0..iters {
+                    if i.is_multiple_of(MAX_OPERATIONS_PER_STORE) {
+                        state = BenchState::new();
+                    }
+
+                    let instant = Instant::now();
+                    state.run_iteration(i, reset_policy);
+                    elapsed += instant.elapsed();
+                }
+                elapsed
+            })
+        });
+    }
+
+    group.finish();
+}
+
+struct BenchState {
+    store: SandboxComponents,
+    env_def: Vec<u8>,
+    supervisor: NoopSupervisor,
+}
+
+impl BenchState {
+    fn new() -> Self {
+        Self {
+            store: SandboxComponents::new(SandboxBackend::Wasmtime),
+            env_def: EnvironmentDefinition {
+                entries: Vec::new(),
+            }
+            .encode(),
+            supervisor: NoopSupervisor,
+        }
+    }
+
+    fn run_iteration(&mut self, iteration: u64, reset_policy: ResetPolicy) {
+        let memory_idx = self
+            .store
+            .new_memory(1, 1)
+            .expect("failed to create sandbox memory");
+        black_box(memory_idx);
+
+        let guest_env = GuestEnvironment::decode(&self.store, &self.env_def)
+            .unwrap_or_else(|_| panic!("failed to decode env"));
+        let instance = self
+            .store
+            .instantiate(
+                Instantiate::Version1,
+                EMPTY_WASM,
+                guest_env,
+                &mut self.supervisor,
+            )
+            .unwrap_or_else(|_| panic!("failed to instantiate empty wasm"));
+        let instance_idx = instance.register(&mut self.store, self.supervisor.dispatch_thunk_id());
+        black_box(instance_idx);
+
+        if let ResetPolicy::Every(clear_every) = reset_policy
+            && iteration.is_multiple_of(clear_every as u64)
+        {
+            self.store.clear();
+        }
+    }
+}
+
+criterion_group!(benches, bench_wasmtime_store_growth);
+criterion_main!(benches);