pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-26 08:47:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Executor: Remove LegacyInstanceReuse strategy (#1486)

Browse Source 
It seems the old strategy have been depracted more than one year. 
So maybe it's time to clean up old strategy for wasm executor.


---
polkadot address: 15ouFh2SHpGbHtDPsJ6cXQfes9Cx1gEFnJJsJVqPGzBSTudr

---------

Co-authored-by: Bastian Köcher <git@kchr.de>
Co-authored-by: Koute <koute@users.noreply.github.com>
This commit is contained in:
yjh
2023-09-18 13:53:06 +08:00
committed by GitHub
parent cf5c195237
commit e38998801e
16 changed files with 20 additions and 710 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/client/executor/src/integration_tests/linux.rs
-84
View File
@@ -1,84 +0,0 @@
// This file is part of Substrate.
// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//! Tests that are only relevant for Linux.
mod smaps;
use super::mk_test_runtime;
use crate::WasmExecutionMethod;
use codec::Encode as _;
use sc_executor_common::wasm_runtime::DEFAULT_HEAP_ALLOC_STRATEGY;
use self::smaps::Smaps;
#[test]
fn memory_consumption_compiled() {
let _ = sp_tracing::try_init_simple();
if std::env::var("RUN_TEST").is_ok() {
memory_consumption(WasmExecutionMethod::Compiled {
instantiation_strategy:
sc_executor_wasmtime::InstantiationStrategy::LegacyInstanceReuse,
});
} else {
// We need to run the test in isolation, to not getting interfered by the other tests.
let executable = std::env::current_exe().unwrap();
let status = std::process::Command::new(executable)
.env("RUN_TEST", "1")
.args(&["--nocapture", "memory_consumption_compiled"])
.status()
.unwrap();
assert!(status.success());
}
}
fn memory_consumption(wasm_method: WasmExecutionMethod) {
// This aims to see if linear memory stays backed by the physical memory after a runtime call.
//
// For that we make a series of runtime calls, probing the RSS for the VMA matching the linear
// memory. After the call we expect RSS to be equal to 0.
let runtime = mk_test_runtime(wasm_method, DEFAULT_HEAP_ALLOC_STRATEGY);
let mut instance = runtime.new_instance().unwrap();
let heap_base = instance
.get_global_const("__heap_base")
.expect("`__heap_base` is valid")
.expect("`__heap_base` exists")
.as_i32()
.expect("`__heap_base` is an `i32`");
fn probe_rss(instance: &dyn sc_executor_common::wasm_runtime::WasmInstance) -> usize {
let base_addr = instance.linear_memory_base_ptr().unwrap() as usize;
Smaps::new().get_rss(base_addr).expect("failed to get rss")
}
instance
.call_export("test_dirty_plenty_memory", &(heap_base as u32, 1u32).encode())
.unwrap();
let probe_1 = probe_rss(&*instance);
instance
.call_export("test_dirty_plenty_memory", &(heap_base as u32, 1024u32).encode())
.unwrap();
let probe_2 = probe_rss(&*instance);
assert_eq!(probe_1, 0);
assert_eq!(probe_2, 0);
}
substrate/client/executor/src/integration_tests/linux/smaps.rs
-82
View File
@@ -1,82 +0,0 @@
// This file is part of Substrate.
// Copyright (C) Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: GPL-3.0-or-later WITH Classpath-exception-2.0
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
//! A tool for extracting information about the memory consumption of the current process from
//! the procfs.
use std::{collections::BTreeMap, ops::Range};
/// An interface to the /proc/self/smaps
///
/// See docs about [procfs on kernel.org][procfs]
///
/// [procfs]: https://www.kernel.org/doc/html/latest/filesystems/proc.html
pub struct Smaps(Vec<(Range<usize>, BTreeMap<String, usize>)>);
impl Smaps {
pub fn new() -> Self {
let regex_start = regex::RegexBuilder::new("^([0-9a-f]+)-([0-9a-f]+)")
.multi_line(true)
.build()
.unwrap();
let regex_kv = regex::RegexBuilder::new(r#"^([^:]+):\s*(\d+) kB"#)
.multi_line(true)
.build()
.unwrap();
let smaps = std::fs::read_to_string("/proc/self/smaps").unwrap();
let boundaries: Vec<_> = regex_start
.find_iter(&smaps)
.map(|matched| matched.start())
.chain(std::iter::once(smaps.len()))
.collect();
let mut output = Vec::new();
for window in boundaries.windows(2) {
let chunk = &smaps[window[0]..window[1]];
let caps = regex_start.captures(chunk).unwrap();
let start = usize::from_str_radix(caps.get(1).unwrap().as_str(), 16).unwrap();
let end = usize::from_str_radix(caps.get(2).unwrap().as_str(), 16).unwrap();
let values = regex_kv
.captures_iter(chunk)
.map(|cap| {
let key = cap.get(1).unwrap().as_str().to_owned();
let value = cap.get(2).unwrap().as_str().parse().unwrap();
(key, value)
})
.collect();
output.push((start..end, values));
}
Self(output)
}
fn get_map(&self, addr: usize) -> &BTreeMap<String, usize> {
&self
.0
.iter()
.find(|(range, _)| addr >= range.start && addr < range.end)
.unwrap()
.1
}
pub fn get_rss(&self, addr: usize) -> Option<usize> {
self.get_map(addr).get("Rss").cloned()
}
}
substrate/client/executor/src/integration_tests/mod.rs
-11
View File
@@ -16,9 +16,6 @@
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
#[cfg(target_os = "linux")]
mod linux;
use assert_matches::assert_matches;
use codec::{Decode, Encode};
use sc_executor_common::{
@@ -81,14 +78,6 @@ macro_rules! test_wasm_execution {
instantiation_strategy: sc_executor_wasmtime::InstantiationStrategy::Pooling
});
}
#[test]
fn [<$method_name _compiled_legacy_instance_reuse>]() {
let _ = sp_tracing::try_init_simple();
$method_name(WasmExecutionMethod::Compiled {
instantiation_strategy: sc_executor_wasmtime::InstantiationStrategy::LegacyInstanceReuse
});
}
}
};
}