pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-07-24 14:45:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove sp_tasks::spawn API and related code + host functions (#12639)

Browse Source 
* Remove `sp_tasks::spawn` API and related code

* Remove `RuntimeTasks::{spawn, join}` host functions

* remove unused

* Remove a few more tests that I forgot to remove

Co-authored-by: Shawn Tabrizi <shawntabrizi@gmail.com>
This commit is contained in:
Koute
2022-11-10 21:23:56 +09:00
committed by GitHub
parent 9979acb1e7
commit 5c7ec6909d
18 changed files with 10 additions and 1147 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/primitives/core/src/traits.rs
-6
View File
@@ -179,12 +179,6 @@ pub trait RuntimeSpawn: Send {
fn join(&self, handle: u64) -> Vec<u8>;
}
#[cfg(feature = "std")]
sp_externalities::decl_extension! {
/// Extension that supports spawning extra runtime instances in externalities.
pub struct RuntimeSpawnExt(Box<dyn RuntimeSpawn>);
}
/// Something that can spawn tasks (blocking and non-blocking) with an assigned name
/// and optional group.
#[dyn_clonable::clonable]
substrate/primitives/io/src/lib.rs
+1 -34
View File
@@ -40,7 +40,7 @@ use sp_core::{
hexdisplay::HexDisplay,
offchain::{OffchainDbExt, OffchainWorkerExt, TransactionPoolExt},
storage::ChildInfo,
traits::{RuntimeSpawnExt, TaskExecutorExt},
traits::TaskExecutorExt,
};
#[cfg(feature = "std")]
use sp_keystore::{KeystoreExt, SyncCryptoStore};
@@ -1657,38 +1657,6 @@ pub trait Sandbox {
}
}
/// Wasm host functions for managing tasks.
///
/// This should not be used directly. Use `sp_tasks` for running parallel tasks instead.
#[runtime_interface(wasm_only)]
pub trait RuntimeTasks {
/// Wasm host function for spawning task.
///
/// This should not be used directly. Use `sp_tasks::spawn` instead.
fn spawn(dispatcher_ref: u32, entry: u32, payload: Vec<u8>) -> u64 {
sp_externalities::with_externalities(|mut ext| {
let runtime_spawn = ext
.extension::<RuntimeSpawnExt>()
.expect("Cannot spawn without dynamic runtime dispatcher (RuntimeSpawnExt)");
runtime_spawn.spawn_call(dispatcher_ref, entry, payload)
})
.expect("`RuntimeTasks::spawn`: called outside of externalities context")
}
/// Wasm host function for joining a task.
///
/// This should not be used directly. Use `join` of `sp_tasks::spawn` result instead.
fn join(handle: u64) -> Vec<u8> {
sp_externalities::with_externalities(|mut ext| {
let runtime_spawn = ext
.extension::<RuntimeSpawnExt>()
.expect("Cannot join without dynamic runtime dispatcher (RuntimeSpawnExt)");
runtime_spawn.join(handle)
})
.expect("`RuntimeTasks::join`: called outside of externalities context")
}
}
/// Allocator used by Substrate when executing the Wasm runtime.
#[cfg(all(target_arch = "wasm32", not(feature = "std")))]
struct WasmAllocator;
@@ -1767,7 +1735,6 @@ pub type SubstrateHostFunctions = (
sandbox::HostFunctions,
crate::trie::HostFunctions,
offchain_index::HostFunctions,
runtime_tasks::HostFunctions,
transaction_index::HostFunctions,
);
substrate/primitives/tasks/Cargo.toml
-36
View File
@@ -1,36 +0,0 @@
[package]
name = "sp-tasks"
version = "4.0.0-dev"
authors = ["Parity Technologies <admin@parity.io>"]
edition = "2021"
license = "Apache-2.0"
homepage = "https://substrate.io"
repository = "https://github.com/paritytech/substrate/"
description = "Runtime asynchronous, pure computational tasks"
documentation = "https://docs.rs/sp-tasks"
readme = "README.md"
[package.metadata.docs.rs]
targets = ["x86_64-unknown-linux-gnu"]
[dependencies]
log = { version = "0.4.17", optional = true }
sp-core = { version = "6.0.0", default-features = false, path = "../core" }
sp-externalities = { version = "0.12.0", optional = true, path = "../externalities" }
sp-io = { version = "6.0.0", default-features = false, path = "../io" }
sp-runtime-interface = { version = "6.0.0", default-features = false, path = "../runtime-interface" }
sp-std = { version = "4.0.0", default-features = false, path = "../std" }
[dev-dependencies]
codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false }
[features]
default = ["std"]
std = [
"log",
"sp-core/std",
"sp-externalities",
"sp-io/std",
"sp-runtime-interface/std",
"sp-std/std",
]
substrate/primitives/tasks/README.md
-3
View File
@@ -1,3 +0,0 @@
Runtime asynchronous, pure computational tasks.
License: Apache-2.0
substrate/primitives/tasks/src/async_externalities.rs
-212
View File
@@ -1,212 +0,0 @@
// This file is part of Substrate.
// Copyright (C) 2020-2022 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/>.
//! Async externalities.
use sp_core::{
storage::{ChildInfo, StateVersion, TrackedStorageKey},
traits::{Externalities, RuntimeSpawn, RuntimeSpawnExt, SpawnNamed, TaskExecutorExt},
};
use sp_externalities::{Extensions, ExternalitiesExt as _, MultiRemovalResults};
use std::any::{Any, TypeId};
/// Simple state-less externalities for use in async context.
///
/// Will panic if anything is accessing the storage.
#[derive(Debug)]
pub struct AsyncExternalities {
extensions: Extensions,
}
/// New Async externalities.
pub fn new_async_externalities(
scheduler: Box<dyn SpawnNamed>,
) -> Result<AsyncExternalities, &'static str> {
let mut res = AsyncExternalities { extensions: Default::default() };
let mut ext = &mut res as &mut dyn Externalities;
ext.register_extension::<TaskExecutorExt>(TaskExecutorExt(scheduler.clone()))
.map_err(|_| "Failed to register task executor extension.")?;
Ok(res)
}
impl AsyncExternalities {
/// Extend async externalities with the ability to spawn wasm instances.
pub fn with_runtime_spawn(
mut self,
runtime_ext: Box<dyn RuntimeSpawn>,
) -> Result<Self, &'static str> {
let mut ext = &mut self as &mut dyn Externalities;
ext.register_extension::<RuntimeSpawnExt>(RuntimeSpawnExt(runtime_ext))
.map_err(|_| "Failed to register task executor extension.")?;
Ok(self)
}
}
type StorageKey = Vec<u8>;
type StorageValue = Vec<u8>;
impl Externalities for AsyncExternalities {
fn set_offchain_storage(&mut self, _key: &[u8], _value: Option<&[u8]>) {
panic!("`set_offchain_storage`: should not be used in async externalities!")
}
fn storage(&self, _key: &[u8]) -> Option<StorageValue> {
panic!("`storage`: should not be used in async externalities!")
}
fn storage_hash(&self, _key: &[u8]) -> Option<Vec<u8>> {
panic!("`storage_hash`: should not be used in async externalities!")
}
fn child_storage(&self, _child_info: &ChildInfo, _key: &[u8]) -> Option<StorageValue> {
panic!("`child_storage`: should not be used in async externalities!")
}
fn child_storage_hash(&self, _child_info: &ChildInfo, _key: &[u8]) -> Option<Vec<u8>> {
panic!("`child_storage_hash`: should not be used in async externalities!")
}
fn next_storage_key(&self, _key: &[u8]) -> Option<StorageKey> {
panic!("`next_storage_key`: should not be used in async externalities!")
}
fn next_child_storage_key(&self, _child_info: &ChildInfo, _key: &[u8]) -> Option<StorageKey> {
panic!("`next_child_storage_key`: should not be used in async externalities!")
}
fn place_storage(&mut self, _key: StorageKey, _maybe_value: Option<StorageValue>) {
panic!("`place_storage`: should not be used in async externalities!")
}
fn place_child_storage(
&mut self,
_child_info: &ChildInfo,
_key: StorageKey,
_value: Option<StorageValue>,
) {
panic!("`place_child_storage`: should not be used in async externalities!")
}
fn kill_child_storage(
&mut self,
_child_info: &ChildInfo,
_maybe_limit: Option<u32>,
_maybe_cursor: Option<&[u8]>,
) -> MultiRemovalResults {
panic!("`kill_child_storage`: should not be used in async externalities!")
}
fn clear_prefix(
&mut self,
_prefix: &[u8],
_maybe_limit: Option<u32>,
_maybe_cursor: Option<&[u8]>,
) -> MultiRemovalResults {
panic!("`clear_prefix`: should not be used in async externalities!")
}
fn clear_child_prefix(
&mut self,
_child_info: &ChildInfo,
_prefix: &[u8],
_maybe_limit: Option<u32>,
_maybe_cursor: Option<&[u8]>,
) -> MultiRemovalResults {
panic!("`clear_child_prefix`: should not be used in async externalities!")
}
fn storage_append(&mut self, _key: Vec<u8>, _value: Vec<u8>) {
panic!("`storage_append`: should not be used in async externalities!")
}
fn storage_root(&mut self, _state_version: StateVersion) -> Vec<u8> {
panic!("`storage_root`: should not be used in async externalities!")
}
fn child_storage_root(
&mut self,
_child_info: &ChildInfo,
_state_version: StateVersion,
) -> Vec<u8> {
panic!("`child_storage_root`: should not be used in async externalities!")
}
fn storage_start_transaction(&mut self) {
unimplemented!("Transactions are not supported by AsyncExternalities");
}
fn storage_rollback_transaction(&mut self) -> Result<(), ()> {
unimplemented!("Transactions are not supported by AsyncExternalities");
}
fn storage_commit_transaction(&mut self) -> Result<(), ()> {
unimplemented!("Transactions are not supported by AsyncExternalities");
}
fn wipe(&mut self) {}
fn commit(&mut self) {}
fn read_write_count(&self) -> (u32, u32, u32, u32) {
unimplemented!("read_write_count is not supported in AsyncExternalities")
}
fn reset_read_write_count(&mut self) {
unimplemented!("reset_read_write_count is not supported in AsyncExternalities")
}
fn get_whitelist(&self) -> Vec<TrackedStorageKey> {
unimplemented!("get_whitelist is not supported in AsyncExternalities")
}
fn set_whitelist(&mut self, _: Vec<TrackedStorageKey>) {
unimplemented!("set_whitelist is not supported in AsyncExternalities")
}
fn get_read_and_written_keys(&self) -> Vec<(Vec<u8>, u32, u32, bool)> {
unimplemented!("get_read_and_written_keys is not supported in AsyncExternalities")
}
}
impl sp_externalities::ExtensionStore for AsyncExternalities {
fn extension_by_type_id(&mut self, type_id: TypeId) -> Option<&mut dyn Any> {
self.extensions.get_mut(type_id)
}
fn register_extension_with_type_id(
&mut self,
type_id: TypeId,
extension: Box<dyn sp_externalities::Extension>,
) -> Result<(), sp_externalities::Error> {
self.extensions.register_with_type_id(type_id, extension)
}
fn deregister_extension_by_type_id(
&mut self,
type_id: TypeId,
) -> Result<(), sp_externalities::Error> {
if self.extensions.deregister(type_id) {
Ok(())
} else {
Err(sp_externalities::Error::ExtensionIsNotRegistered(type_id))
}
}
}
substrate/primitives/tasks/src/lib.rs
-257
View File
@@ -1,257 +0,0 @@
// This file is part of Substrate.
// Copyright (C) 2020-2022 Parity Technologies (UK) Ltd.
// SPDX-License-Identifier: Apache-2.0
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//! Runtime tasks.
//!
//! Contains runtime-usable functions for spawning parallel purely computational tasks.
//!
//! NOTE: This is experimental API.
//! NOTE: When using in actual runtime, make sure you don't produce unbounded parallelism.
//! So this is bad example to use it:
//! ```rust
//! fn my_parallel_computator(data: Vec<u8>) -> Vec<u8> {
//! unimplemented!()
//! }
//! fn test(dynamic_variable: i32) {
//! for _ in 0..dynamic_variable { sp_tasks::spawn(my_parallel_computator, vec![]); }
//! }
//! ```
//!
//! While this is a good example:
//! ```rust
//! use codec::Encode;
//! static STATIC_VARIABLE: i32 = 4;
//!
//! fn my_parallel_computator(data: Vec<u8>) -> Vec<u8> {
//! unimplemented!()
//! }
//!
//! fn test(computation_payload: Vec<u8>) {
//! let parallel_tasks = (0..STATIC_VARIABLE).map(|idx|
//! sp_tasks::spawn(my_parallel_computator, computation_payload.chunks(10).nth(idx as _).encode())
//! );
//! }
//! ```
//!
//! When allowing unbounded parallelism, malicious transactions can exploit it and partition
//! network consensus based on how much resources nodes have.
#![cfg_attr(not(feature = "std"), no_std)]
#[cfg(feature = "std")]
mod async_externalities;
#[cfg(feature = "std")]
pub use async_externalities::{new_async_externalities, AsyncExternalities};
#[cfg(feature = "std")]
mod inner {
use sp_core::traits::TaskExecutorExt;
use sp_externalities::ExternalitiesExt as _;
use std::{panic::AssertUnwindSafe, sync::mpsc};
/// Task handle (wasm).
///
/// This can be `join`-ed to get (blocking) the result of
/// the spawned task execution.
#[must_use]
pub struct DataJoinHandle {
receiver: mpsc::Receiver<Vec<u8>>,
}
impl DataJoinHandle {
/// Join handle returned by `spawn` function
pub fn join(self) -> Vec<u8> {
self.receiver
.recv()
.expect("Spawned runtime task terminated before sending result.")
}
}
/// Spawn new runtime task (native).
pub fn spawn(entry_point: fn(Vec<u8>) -> Vec<u8>, data: Vec<u8>) -> DataJoinHandle {
let scheduler = sp_externalities::with_externalities(|mut ext| {
ext.extension::<TaskExecutorExt>()
.expect("No task executor associated with the current context!")
.clone()
})
.expect("Spawn called outside of externalities context!");
let (sender, receiver) = mpsc::channel();
let extra_scheduler = scheduler.clone();
scheduler.spawn(
"parallel-runtime-spawn",
Some("substrate-runtime"),
Box::pin(async move {
let result = match crate::new_async_externalities(extra_scheduler) {
Ok(mut ext) => {
let mut ext = AssertUnwindSafe(&mut ext);
match std::panic::catch_unwind(move || {
sp_externalities::set_and_run_with_externalities(
&mut **ext,
move || entry_point(data),
)
}) {
Ok(result) => result,
Err(panic) => {
log::error!(
target: "runtime",
"Spawned task panicked: {:?}",
panic,
);
// This will drop sender without sending anything.
return
},
}
},
Err(e) => {
log::error!(
target: "runtime",
"Unable to run async task: {}",
e,
);
return
},
};
let _ = sender.send(result);
}),
);
DataJoinHandle { receiver }
}
}
#[cfg(not(feature = "std"))]
mod inner {
use core::mem;
use sp_std::prelude::*;
/// Dispatch wrapper for wasm blob.
///
/// Serves as trampoline to call any rust function with (Vec<u8>) -> Vec<u8> compiled
/// into the runtime.
///
/// Function item should be provided with `func_ref`. Argument for the call
/// will be generated from bytes at `payload_ptr` with `payload_len`.
///
/// NOTE: Since this dynamic dispatch function and the invoked function are compiled with
/// the same compiler, there should be no problem with ABI incompatibility.
extern "C" fn dispatch_wrapper(
func_ref: *const u8,
payload_ptr: *mut u8,
payload_len: u32,
) -> u64 {
let payload_len = payload_len as usize;
let output = unsafe {
let payload = Vec::from_raw_parts(payload_ptr, payload_len, payload_len);
let ptr: fn(Vec<u8>) -> Vec<u8> = mem::transmute(func_ref);
(ptr)(payload)
};
sp_runtime_interface::pack_ptr_and_len(output.as_ptr() as usize as _, output.len() as _)
}
/// Spawn new runtime task (wasm).
pub fn spawn(entry_point: fn(Vec<u8>) -> Vec<u8>, payload: Vec<u8>) -> DataJoinHandle {
let func_ptr: usize = unsafe { mem::transmute(entry_point) };
let handle =
sp_io::runtime_tasks::spawn(dispatch_wrapper as usize as _, func_ptr as u32, payload);
DataJoinHandle { handle }
}
/// Task handle (wasm).
///
/// This can be `join`-ed to get (blocking) the result of
/// the spawned task execution.
#[must_use]
pub struct DataJoinHandle {
handle: u64,
}
impl DataJoinHandle {
/// Join handle returned by `spawn` function
pub fn join(self) -> Vec<u8> {
sp_io::runtime_tasks::join(self.handle)
}
}
}
pub use inner::{spawn, DataJoinHandle};
#[cfg(test)]
mod tests {
use super::*;
fn async_runner(mut data: Vec<u8>) -> Vec<u8> {
data.sort();
data
}
fn async_panicker(_data: Vec<u8>) -> Vec<u8> {
panic!("panic in async panicker!")
}
#[test]
fn basic() {
sp_io::TestExternalities::default().execute_with(|| {
let a1 = spawn(async_runner, vec![5, 2, 1]).join();
assert_eq!(a1, vec![1, 2, 5]);
})
}
#[test]
fn panicking() {
let res = sp_io::TestExternalities::default().execute_with_safe(|| {
spawn(async_panicker, vec![5, 2, 1]).join();
});
assert!(res.unwrap_err().contains("Closure panicked"));
}
#[test]
fn many_joins() {
sp_io::TestExternalities::default()
.execute_with_safe(|| {
// converges to 1 only after 1000+ steps
let mut running_val = 9780657630u64;
let mut data = vec![];
let handles = (0..1024)
.map(|_| {
running_val = if running_val % 2 == 0 {
running_val / 2
} else {
3 * running_val + 1
};
data.push(running_val as u8);
(spawn(async_runner, data.clone()), data.clone())
})
.collect::<Vec<_>>();
for (handle, mut data) in handles {
let result = handle.join();
data.sort();
assert_eq!(result, data);
}
})
.expect("Failed to run with externalities");
}
}