From 020c4df94e2b3b5f0fdce571c8d681f1646f5920 Mon Sep 17 00:00:00 2001 From: Mauro Lacy Date: Mon, 11 Jan 2021 13:11:55 +0100 Subject: [PATCH 1/7] Avoid InMemoryCache store/load serialization/deserialization --- packages/vm/src/cache.rs | 4 ++-- packages/vm/src/modules/in_memory_cache.rs | 23 ++++++++-------------- 2 files changed, 10 insertions(+), 17 deletions(-) diff --git a/packages/vm/src/cache.rs b/packages/vm/src/cache.rs index 7a7b13276e..5d59c15738 100644 --- a/packages/vm/src/cache.rs +++ b/packages/vm/src/cache.rs @@ -116,9 +116,8 @@ where backend: Backend, options: InstanceOptions, ) -> VmResult> { - let store = make_runtime_store(options.memory_limit); // Get module from memory cache - if let Some(module) = self.memory_cache.load(checksum, &store)? { + if let Some(module) = self.memory_cache.load(checksum)? { self.stats.hits_memory_cache += 1; let instance = Instance::from_module(&module, backend, options.gas_limit, options.print_debug)?; @@ -126,6 +125,7 @@ where } // Get module from file system cache + let store = make_runtime_store(options.memory_limit); if let Some(module) = self.fs_cache.load(checksum, &store)? { self.stats.hits_fs_cache += 1; let instance = diff --git a/packages/vm/src/modules/in_memory_cache.rs b/packages/vm/src/modules/in_memory_cache.rs index b1c0ad463d..7529dce165 100644 --- a/packages/vm/src/modules/in_memory_cache.rs +++ b/packages/vm/src/modules/in_memory_cache.rs @@ -1,5 +1,5 @@ use clru::CLruCache; -use wasmer::{Module, Store}; +use wasmer::Module; use crate::{Checksum, Size, VmResult}; @@ -7,7 +7,7 @@ const ESTIMATED_MODULE_SIZE: Size = Size::mebi(10); /// An in-memory module cache pub struct InMemoryCache { - artifacts: CLruCache>, + artifacts: CLruCache, } impl InMemoryCache { @@ -20,19 +20,15 @@ impl InMemoryCache { } pub fn store(&mut self, checksum: &Checksum, module: Module) -> VmResult<()> { - let serialized_artifact = module.serialize()?; - self.artifacts.put(*checksum, serialized_artifact); + self.artifacts.put(*checksum, module); Ok(()) } /// Looks up a module in the cache and takes its artifact and /// creates a new module from store and artifact. - pub fn load(&mut self, checksum: &Checksum, store: &Store) -> VmResult> { + pub fn load(&mut self, checksum: &Checksum) -> VmResult> { match self.artifacts.get(checksum) { - Some(serialized_artifact) => { - let new_module = unsafe { Module::deserialize(store, &serialized_artifact) }?; - Ok(Some(new_module)) - } + Some(module) => Ok(Some(module.clone())), None => Ok(None), } } @@ -42,11 +38,10 @@ impl InMemoryCache { mod tests { use super::*; use crate::size::Size; - use crate::wasm_backend::{compile_only, make_runtime_store}; + use crate::wasm_backend::compile_only; use wasmer::{imports, Instance as WasmerInstance}; use wasmer_middlewares::metering::set_remaining_points; - const TESTING_MEMORY_LIMIT: Size = Size::mebi(16); const TESTING_GAS_LIMIT: u64 = 5_000; #[test] @@ -67,8 +62,7 @@ mod tests { let checksum = Checksum::generate(&wasm); // Module does not exist - let store = make_runtime_store(TESTING_MEMORY_LIMIT); - let cache_entry = cache.load(&checksum, &store).unwrap(); + let cache_entry = cache.load(&checksum).unwrap(); assert!(cache_entry.is_none()); // Compile module @@ -87,8 +81,7 @@ mod tests { cache.store(&checksum, original).unwrap(); // Load module - let store = make_runtime_store(TESTING_MEMORY_LIMIT); - let cached = cache.load(&checksum, &store).unwrap().unwrap(); + let cached = cache.load(&checksum).unwrap().unwrap(); // Ensure cached module can be executed { From af4bf73872b33fdcf81e5b08243ab26387c444f0 Mon Sep 17 00:00:00 2001 From: Mauro Lacy Date: Mon, 11 Jan 2021 13:32:19 +0100 Subject: [PATCH 2/7] Add memory-cache dev branch to CI benchmarking branches --- .circleci/config.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.circleci/config.yml b/.circleci/config.yml index 2b9f83afd9..71a7a0065c 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -27,6 +27,7 @@ workflows: - master - /^[0-9]+\.[0-9]+$/ # 👇 Add your branch here if benchmarking matters to your work + - memory-cache-avoid-serialization - benchmarking - update-wasmer - metering-restart From 4e0b1be8afbda8a5a3974e576227f1201f81e489 Mon Sep 17 00:00:00 2001 From: Mauro Lacy Date: Mon, 11 Jan 2021 18:34:51 +0100 Subject: [PATCH 3/7] Rename InMemoryCache artifacts to modules --- packages/vm/src/modules/in_memory_cache.rs | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/packages/vm/src/modules/in_memory_cache.rs b/packages/vm/src/modules/in_memory_cache.rs index 7529dce165..3a3526703d 100644 --- a/packages/vm/src/modules/in_memory_cache.rs +++ b/packages/vm/src/modules/in_memory_cache.rs @@ -7,7 +7,7 @@ const ESTIMATED_MODULE_SIZE: Size = Size::mebi(10); /// An in-memory module cache pub struct InMemoryCache { - artifacts: CLruCache, + modules: CLruCache, } impl InMemoryCache { @@ -15,19 +15,19 @@ impl InMemoryCache { pub fn new(size: Size) -> Self { let max_entries = size.0 / ESTIMATED_MODULE_SIZE.0; InMemoryCache { - artifacts: CLruCache::new(max_entries), + modules: CLruCache::new(max_entries), } } pub fn store(&mut self, checksum: &Checksum, module: Module) -> VmResult<()> { - self.artifacts.put(*checksum, module); + self.modules.put(*checksum, module); Ok(()) } /// Looks up a module in the cache and takes its artifact and /// creates a new module from store and artifact. pub fn load(&mut self, checksum: &Checksum) -> VmResult> { - match self.artifacts.get(checksum) { + match self.modules.get(checksum) { Some(module) => Ok(Some(module.clone())), None => Ok(None), } From f1922f4cb4bddba47130dcc6834bc6a6dfd63d28 Mon Sep 17 00:00:00 2001 From: Mauro Lacy Date: Tue, 12 Jan 2021 10:32:20 +0100 Subject: [PATCH 4/7] Remove memory_limit from InstanceOptions --- contracts/reflect/tests/integration.rs | 3 ++- contracts/staking/tests/integration.rs | 6 ++++-- packages/vm/benches/main.rs | 12 ++++++++---- packages/vm/src/cache.rs | 21 +++++++++++++++------ packages/vm/src/instance.rs | 12 +++++++----- packages/vm/src/testing/instance.rs | 18 ++++++++++-------- 6 files changed, 46 insertions(+), 26 deletions(-) diff --git a/contracts/reflect/tests/integration.rs b/contracts/reflect/tests/integration.rs index f14ff6f70f..4524b11703 100644 --- a/contracts/reflect/tests/integration.rs +++ b/contracts/reflect/tests/integration.rs @@ -176,7 +176,8 @@ fn dispatch_custom_query() { // stub gives us defaults. Consume it and override... let custom = mock_dependencies_with_custom_querier(&[]); // we cannot use mock_instance, so we just copy and modify code from cosmwasm_vm::testing - let mut deps = Instance::from_code(WASM, custom, mock_instance_options()).unwrap(); + let (instance_options, memory_limit) = mock_instance_options(); + let mut deps = Instance::from_code(WASM, custom, instance_options, memory_limit).unwrap(); // we don't even initialize, just trigger a query let res = query( diff --git a/contracts/staking/tests/integration.rs b/contracts/staking/tests/integration.rs index fc6fdf6196..bf54d9cd45 100644 --- a/contracts/staking/tests/integration.rs +++ b/contracts/staking/tests/integration.rs @@ -47,7 +47,8 @@ fn initialization_with_missing_validator() { backend .querier .update_staking("ustake", &[sample_validator("john")], &[]); - let mut deps = Instance::from_code(WASM, backend, mock_instance_options()).unwrap(); + let (instance_options, memory_limit) = mock_instance_options(); + let mut deps = Instance::from_code(WASM, backend, instance_options, memory_limit).unwrap(); let creator = HumanAddr::from("creator"); let msg = InitMsg { @@ -82,7 +83,8 @@ fn proper_initialization() { ], &[], ); - let mut deps = Instance::from_code(WASM, backend, mock_instance_options()).unwrap(); + let (instance_options, memory_limit) = mock_instance_options(); + let mut deps = Instance::from_code(WASM, backend, instance_options, memory_limit).unwrap(); assert_eq!(deps.required_features.len(), 1); assert!(deps.required_features.contains("staking")); diff --git a/packages/vm/benches/main.rs b/packages/vm/benches/main.rs index 42482a9afe..86a452e1ea 100644 --- a/packages/vm/benches/main.rs +++ b/packages/vm/benches/main.rs @@ -17,7 +17,6 @@ const DEFAULT_GAS_LIMIT: u64 = 400_000; const DEFAULT_INSTANCE_OPTIONS: InstanceOptions = InstanceOptions { gas_limit: DEFAULT_GAS_LIMIT, print_debug: false, - memory_limit: DEFAULT_MEMORY_LIMIT, }; // Cache const MEMORY_CACHE_SIZE: Size = Size::mebi(200); @@ -30,8 +29,9 @@ fn bench_instance(c: &mut Criterion) { group.bench_function("compile and instantiate", |b| { b.iter(|| { let backend = mock_backend(&[]); + let (instance_options, memory_limit) = mock_instance_options(); let _instance = - Instance::from_code(CONTRACT, backend, mock_instance_options()).unwrap(); + Instance::from_code(CONTRACT, backend, instance_options, memory_limit).unwrap(); }); }); @@ -41,7 +41,8 @@ fn bench_instance(c: &mut Criterion) { gas_limit: 500_000_000_000, ..DEFAULT_INSTANCE_OPTIONS }; - let mut instance = Instance::from_code(CONTRACT, backend, much_gas).unwrap(); + let mut instance = + Instance::from_code(CONTRACT, backend, much_gas, DEFAULT_MEMORY_LIMIT).unwrap(); b.iter(|| { let info = mock_info("creator", &coins(1000, "earth")); @@ -58,7 +59,8 @@ fn bench_instance(c: &mut Criterion) { gas_limit: 500_000_000_000, ..DEFAULT_INSTANCE_OPTIONS }; - let mut instance = Instance::from_code(CONTRACT, backend, much_gas).unwrap(); + let mut instance = + Instance::from_code(CONTRACT, backend, much_gas, DEFAULT_MEMORY_LIMIT).unwrap(); let info = mock_info("creator", &coins(1000, "earth")); let msg = br#"{"verifier": "verifies", "beneficiary": "benefits"}"#; @@ -85,6 +87,7 @@ fn bench_cache(c: &mut Criterion) { base_dir: TempDir::new().unwrap().into_path(), supported_features: features_from_csv("staking"), memory_cache_size: MEMORY_CACHE_SIZE, + memory_instances_limit: DEFAULT_MEMORY_LIMIT, }; group.bench_function("save wasm", |b| { @@ -102,6 +105,7 @@ fn bench_cache(c: &mut Criterion) { base_dir: TempDir::new().unwrap().into_path(), supported_features: features_from_csv("staking"), memory_cache_size: Size(0), + memory_instances_limit: DEFAULT_MEMORY_LIMIT, }; let mut cache: Cache = unsafe { Cache::new(non_memcache).unwrap() }; diff --git a/packages/vm/src/cache.rs b/packages/vm/src/cache.rs index 5d59c15738..4c71adcb26 100644 --- a/packages/vm/src/cache.rs +++ b/packages/vm/src/cache.rs @@ -28,11 +28,17 @@ pub struct CacheOptions { pub base_dir: PathBuf, pub supported_features: HashSet, pub memory_cache_size: Size, + /// Memory limit for instances, in bytes. Use a value that is divisible by the Wasm page size 65536, + /// e.g. full MiBs. + pub memory_instances_limit: Size, } pub struct Cache { wasm_path: PathBuf, supported_features: HashSet, + /// Instances memory limit in bytes. Use a value that is divisible by the Wasm page size 65536, + /// e.g. full MiBs. + instance_memory_limit: Size, memory_cache: InMemoryCache, fs_cache: FileSystemCache, stats: Stats, @@ -56,12 +62,13 @@ where /// /// This function is marked unsafe due to `FileSystemCache::new`, which implicitly /// assumes the disk contents are correct, and there's no way to ensure the artifacts - // stored in the cache haven't been corrupted or tampered with. + /// stored in the cache haven't been corrupted or tampered with. pub unsafe fn new(options: CacheOptions) -> VmResult { let CacheOptions { base_dir, supported_features, memory_cache_size, + memory_instances_limit: instance_memory_limit, } = options; let wasm_path = base_dir.join(WASM_DIR); create_dir_all(&wasm_path) @@ -72,6 +79,7 @@ where Ok(Cache { wasm_path, supported_features, + instance_memory_limit, memory_cache: InMemoryCache::new(memory_cache_size), fs_cache, stats: Stats::default(), @@ -125,7 +133,7 @@ where } // Get module from file system cache - let store = make_runtime_store(options.memory_limit); + let store = make_runtime_store(self.instance_memory_limit); if let Some(module) = self.fs_cache.load(checksum, &store)? { self.stats.hits_fs_cache += 1; let instance = @@ -141,7 +149,7 @@ where // stored the old module format. let wasm = self.load_wasm(checksum)?; self.stats.misses += 1; - let module = compile_and_use(&wasm, options.memory_limit)?; + let module = compile_and_use(&wasm, self.instance_memory_limit)?; let instance = Instance::from_module(&module, backend, options.gas_limit, options.print_debug)?; self.fs_cache.store(checksum, &module)?; @@ -201,7 +209,6 @@ mod tests { const TESTING_MEMORY_LIMIT: Size = Size::mebi(16); const TESTING_OPTIONS: InstanceOptions = InstanceOptions { gas_limit: TESTING_GAS_LIMIT, - memory_limit: TESTING_MEMORY_LIMIT, print_debug: false, }; const TESTING_MEMORY_CACHE_SIZE: Size = Size::mebi(200); @@ -217,6 +224,7 @@ mod tests { base_dir: TempDir::new().unwrap().into_path(), supported_features: default_features(), memory_cache_size: TESTING_MEMORY_CACHE_SIZE, + memory_instances_limit: TESTING_MEMORY_LIMIT, } } @@ -298,6 +306,7 @@ mod tests { base_dir: tmp_dir.path().to_path_buf(), supported_features: default_features(), memory_cache_size: TESTING_MEMORY_CACHE_SIZE, + memory_instances_limit: TESTING_MEMORY_LIMIT, }; let mut cache1: Cache = unsafe { Cache::new(options1).unwrap() }; @@ -309,6 +318,7 @@ mod tests { base_dir: tmp_dir.path().to_path_buf(), supported_features: default_features(), memory_cache_size: TESTING_MEMORY_CACHE_SIZE, + memory_instances_limit: TESTING_MEMORY_LIMIT, }; let cache2: Cache = unsafe { Cache::new(options2).unwrap() }; @@ -342,6 +352,7 @@ mod tests { base_dir: tmp_dir.path().to_path_buf(), supported_features: default_features(), memory_cache_size: TESTING_MEMORY_CACHE_SIZE, + memory_instances_limit: TESTING_MEMORY_LIMIT, }; let mut cache: Cache = unsafe { Cache::new(options).unwrap() }; @@ -582,7 +593,6 @@ mod tests { // Init from module cache let options = InstanceOptions { gas_limit: 10, - memory_limit: TESTING_MEMORY_LIMIT, print_debug: false, }; let mut instance1 = cache.get_instance(&id, backend1, options).unwrap(); @@ -601,7 +611,6 @@ mod tests { // Init from memory cache let options = InstanceOptions { gas_limit: TESTING_GAS_LIMIT, - memory_limit: TESTING_MEMORY_LIMIT, print_debug: false, }; let mut instance2 = cache.get_instance(&id, backend2, options).unwrap(); diff --git a/packages/vm/src/instance.rs b/packages/vm/src/instance.rs index 07d0e63bdc..ded842a6e8 100644 --- a/packages/vm/src/instance.rs +++ b/packages/vm/src/instance.rs @@ -34,8 +34,6 @@ pub struct GasReport { #[derive(Copy, Clone, Debug)] pub struct InstanceOptions { pub gas_limit: u64, - /// Memory limit in bytes. Use a value that is divisible by the Wasm page size 65536, e.g. full MiBs. - pub memory_limit: Size, pub print_debug: bool, } @@ -60,8 +58,9 @@ where code: &[u8], backend: Backend, options: InstanceOptions, + memory_limit: Size, ) -> VmResult { - let module = compile_and_use(code, options.memory_limit)?; + let module = compile_and_use(code, memory_limit)?; Instance::from_module(&module, backend, options.gas_limit, options.print_debug) } @@ -313,7 +312,9 @@ mod tests { #[test] fn required_features_works() { let backend = mock_backend(&[]); - let instance = Instance::from_code(CONTRACT, backend, mock_instance_options()).unwrap(); + let (instance_options, memory_limit) = mock_instance_options(); + let instance = + Instance::from_code(CONTRACT, backend, instance_options, memory_limit).unwrap(); assert_eq!(instance.required_features.len(), 0); } @@ -334,7 +335,8 @@ mod tests { .unwrap(); let backend = mock_backend(&[]); - let instance = Instance::from_code(&wasm, backend, mock_instance_options()).unwrap(); + let (instance_options, memory_limit) = mock_instance_options(); + let instance = Instance::from_code(&wasm, backend, instance_options, memory_limit).unwrap(); assert_eq!(instance.required_features.len(), 3); assert!(instance.required_features.contains("nutrients")); assert!(instance.required_features.contains("sun")); diff --git a/packages/vm/src/testing/instance.rs b/packages/vm/src/testing/instance.rs index 72ad5dd74d..0f9a3ad600 100644 --- a/packages/vm/src/testing/instance.rs +++ b/packages/vm/src/testing/instance.rs @@ -137,21 +137,23 @@ pub fn mock_instance_with_options( storage: MockStorage::default(), querier: MockQuerier::new(&balances), }; + let memory_limit = options.memory_limit; let options = InstanceOptions { gas_limit: options.gas_limit, - memory_limit: options.memory_limit, print_debug: options.print_debug, }; - Instance::from_code(wasm, backend, options).unwrap() + Instance::from_code(wasm, backend, options, memory_limit).unwrap() } /// Creates InstanceOptions for testing -pub fn mock_instance_options() -> InstanceOptions { - InstanceOptions { - gas_limit: DEFAULT_GAS_LIMIT, - memory_limit: DEFAULT_MEMORY_LIMIT, - print_debug: DEFAULT_PRINT_DEBUG, - } +pub fn mock_instance_options() -> (InstanceOptions, Size) { + ( + InstanceOptions { + gas_limit: DEFAULT_GAS_LIMIT, + print_debug: DEFAULT_PRINT_DEBUG, + }, + DEFAULT_MEMORY_LIMIT, + ) } /// Runs a series of IO tests, hammering especially on allocate and deallocate. From fabedbc02d55eb145a728555f9420e7f8ec2dcce Mon Sep 17 00:00:00 2001 From: Mauro Lacy Date: Tue, 12 Jan 2021 12:21:12 +0100 Subject: [PATCH 5/7] s/memory_instances_limit/instance_memory_limit/ --- packages/vm/benches/main.rs | 4 ++-- packages/vm/src/cache.rs | 12 ++++++------ 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/packages/vm/benches/main.rs b/packages/vm/benches/main.rs index 86a452e1ea..c55ecc2e57 100644 --- a/packages/vm/benches/main.rs +++ b/packages/vm/benches/main.rs @@ -87,7 +87,7 @@ fn bench_cache(c: &mut Criterion) { base_dir: TempDir::new().unwrap().into_path(), supported_features: features_from_csv("staking"), memory_cache_size: MEMORY_CACHE_SIZE, - memory_instances_limit: DEFAULT_MEMORY_LIMIT, + instance_memory_limit: DEFAULT_MEMORY_LIMIT, }; group.bench_function("save wasm", |b| { @@ -105,7 +105,7 @@ fn bench_cache(c: &mut Criterion) { base_dir: TempDir::new().unwrap().into_path(), supported_features: features_from_csv("staking"), memory_cache_size: Size(0), - memory_instances_limit: DEFAULT_MEMORY_LIMIT, + instance_memory_limit: DEFAULT_MEMORY_LIMIT, }; let mut cache: Cache = unsafe { Cache::new(non_memcache).unwrap() }; diff --git a/packages/vm/src/cache.rs b/packages/vm/src/cache.rs index 4c71adcb26..25efb5ac7d 100644 --- a/packages/vm/src/cache.rs +++ b/packages/vm/src/cache.rs @@ -30,7 +30,7 @@ pub struct CacheOptions { pub memory_cache_size: Size, /// Memory limit for instances, in bytes. Use a value that is divisible by the Wasm page size 65536, /// e.g. full MiBs. - pub memory_instances_limit: Size, + pub instance_memory_limit: Size, } pub struct Cache { @@ -68,7 +68,7 @@ where base_dir, supported_features, memory_cache_size, - memory_instances_limit: instance_memory_limit, + instance_memory_limit, } = options; let wasm_path = base_dir.join(WASM_DIR); create_dir_all(&wasm_path) @@ -224,7 +224,7 @@ mod tests { base_dir: TempDir::new().unwrap().into_path(), supported_features: default_features(), memory_cache_size: TESTING_MEMORY_CACHE_SIZE, - memory_instances_limit: TESTING_MEMORY_LIMIT, + instance_memory_limit: TESTING_MEMORY_LIMIT, } } @@ -306,7 +306,7 @@ mod tests { base_dir: tmp_dir.path().to_path_buf(), supported_features: default_features(), memory_cache_size: TESTING_MEMORY_CACHE_SIZE, - memory_instances_limit: TESTING_MEMORY_LIMIT, + instance_memory_limit: TESTING_MEMORY_LIMIT, }; let mut cache1: Cache = unsafe { Cache::new(options1).unwrap() }; @@ -318,7 +318,7 @@ mod tests { base_dir: tmp_dir.path().to_path_buf(), supported_features: default_features(), memory_cache_size: TESTING_MEMORY_CACHE_SIZE, - memory_instances_limit: TESTING_MEMORY_LIMIT, + instance_memory_limit: TESTING_MEMORY_LIMIT, }; let cache2: Cache = unsafe { Cache::new(options2).unwrap() }; @@ -352,7 +352,7 @@ mod tests { base_dir: tmp_dir.path().to_path_buf(), supported_features: default_features(), memory_cache_size: TESTING_MEMORY_CACHE_SIZE, - memory_instances_limit: TESTING_MEMORY_LIMIT, + instance_memory_limit: TESTING_MEMORY_LIMIT, }; let mut cache: Cache = unsafe { Cache::new(options).unwrap() }; From 7a033a66fa45466028d93867765587f88b29b417 Mon Sep 17 00:00:00 2001 From: Mauro Lacy Date: Tue, 12 Jan 2021 12:29:49 +0100 Subject: [PATCH 6/7] Update CHANGELOG --- CHANGELOG.md | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index b33f39b8b3..fafdae8da9 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -12,6 +12,13 @@ - Remove `from_address` from `BankMsg::Send`, as it always sends from the contract address, and this is consistent with other `CosmosMsg` variants. +**cosmwasm-vm** + +- Avoid serialization of Modules in `InMemoryCache`, for performance. (#697) + + Also, remove `memory_limit` from `InstanceOptions`, and define it instead at + `Cache` level (same memory limit for all cached instances). + ## 0.13.1 (2020-01-12) **cosmwasm-std** From 94b4308b98c94b095ff2f81cbbda423b21d9b1cf Mon Sep 17 00:00:00 2001 From: Mauro Lacy Date: Tue, 12 Jan 2021 12:45:27 +0100 Subject: [PATCH 7/7] Revert "Add memory-cache dev branch to CI benchmarking branches" This reverts commit af4bf73872b33fdcf81e5b08243ab26387c444f0. --- .circleci/config.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 71a7a0065c..2b9f83afd9 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -27,7 +27,6 @@ workflows: - master - /^[0-9]+\.[0-9]+$/ # 👇 Add your branch here if benchmarking matters to your work - - memory-cache-avoid-serialization - benchmarking - update-wasmer - metering-restart