pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-06-12 20:31:13 +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/Cargo.lock
Generated
-30
View File
@@ -5461,21 +5461,6 @@ dependencies = [
"sp-std",
]
[[package]]
name = "pallet-example-parallel"
version = "3.0.0-dev"
dependencies = [
"frame-support",
"frame-system",
"parity-scale-codec",
"scale-info",
"sp-core",
"sp-io",
"sp-runtime",
"sp-std",
"sp-tasks",
]
[[package]]
name = "pallet-fast-unstake"
version = "4.0.0-dev"
@@ -7988,7 +7973,6 @@ dependencies = [
"sp-runtime",
"sp-runtime-interface",
"sp-state-machine",
"sp-tasks",
"sp-trie",
"sp-version",
"sp-wasm-interface",
@@ -8548,7 +8532,6 @@ dependencies = [
"sp-runtime",
"sp-sandbox",
"sp-std",
"sp-tasks",
"substrate-wasm-builder",
]
@@ -9960,19 +9943,6 @@ dependencies = [
"sp-std",
]
[[package]]
name = "sp-tasks"
version = "4.0.0-dev"
dependencies = [
"log",
"parity-scale-codec",
"sp-core",
"sp-externalities",
"sp-io",
"sp-runtime-interface",
"sp-std",
]
[[package]]
name = "sp-test-primitives"
version = "2.0.0"
substrate/Cargo.toml
-2
View File
@@ -98,7 +98,6 @@ members = [
"frame/election-provider-support/solution-type/fuzzer",
"frame/examples/basic",
"frame/examples/offchain-worker",
"frame/examples/parallel",
"frame/executive",
"frame/gilt",
"frame/grandpa",
@@ -205,7 +204,6 @@ members = [
"primitives/state-machine",
"primitives/std",
"primitives/storage",
"primitives/tasks",
"primitives/test-primitives",
"primitives/timestamp",
"primitives/tracing",
substrate/client/executor/Cargo.toml
-1
View File
@@ -31,7 +31,6 @@ sp-externalities = { version = "0.12.0", path = "../../primitives/externalities"
sp-io = { version = "6.0.0", path = "../../primitives/io" }
sp-panic-handler = { version = "4.0.0", path = "../../primitives/panic-handler" }
sp-runtime-interface = { version = "6.0.0", path = "../../primitives/runtime-interface" }
sp-tasks = { version = "4.0.0-dev", path = "../../primitives/tasks" }
sp-trie = { version = "6.0.0", path = "../../primitives/trie" }
sp-version = { version = "5.0.0", path = "../../primitives/version" }
sp-wasm-interface = { version = "6.0.0", path = "../../primitives/wasm-interface" }
substrate/client/executor/runtime-test/Cargo.toml
-2
View File
@@ -19,7 +19,6 @@ sp-io = { version = "6.0.0", default-features = false, features = ["improved_pan
sp-runtime = { version = "6.0.0", default-features = false, path = "../../../primitives/runtime" }
sp-sandbox = { version = "0.10.0-dev", default-features = false, path = "../../../primitives/sandbox" }
sp-std = { version = "4.0.0", default-features = false, path = "../../../primitives/std" }
sp-tasks = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/tasks" }
[build-dependencies]
substrate-wasm-builder = { version = "5.0.0-dev", path = "../../../utils/wasm-builder" }
@@ -32,5 +31,4 @@ std = [
"sp-runtime/std",
"sp-sandbox/std",
"sp-std/std",
"sp-tasks/std",
]
substrate/client/executor/runtime-test/src/lib.rs
-37
View File
@@ -318,24 +318,6 @@ sp_core::wasm_export_functions! {
message_slice.copy_from_slice(test_message);
}
fn test_spawn() {
let data = vec![1u8, 2u8];
let data_new = sp_tasks::spawn(tasks::incrementer, data).join();
assert_eq!(data_new, vec![2u8, 3u8]);
}
fn test_nested_spawn() {
let data = vec![7u8, 13u8];
let data_new = sp_tasks::spawn(tasks::parallel_incrementer, data).join();
assert_eq!(data_new, vec![10u8, 16u8]);
}
fn test_panic_in_spawned() {
sp_tasks::spawn(tasks::panicker, vec![]).join();
}
fn test_return_i8() -> i8 {
-66
}
@@ -358,25 +340,6 @@ sp_core::wasm_export_functions! {
}
}
#[cfg(not(feature = "std"))]
mod tasks {
use sp_std::prelude::*;
pub fn incrementer(data: Vec<u8>) -> Vec<u8> {
data.into_iter().map(|v| v + 1).collect()
}
pub fn panicker(_: Vec<u8>) -> Vec<u8> {
panic!()
}
pub fn parallel_incrementer(data: Vec<u8>) -> Vec<u8> {
let first = data.into_iter().map(|v| v + 2).collect::<Vec<_>>();
let second = sp_tasks::spawn(incrementer, first).join();
second
}
}
/// A macro to define a test entrypoint for each available sandbox executor.
macro_rules! wasm_export_sandbox_test_functions {
(
substrate/client/executor/src/integration_tests/mod.rs
-27
View File
@@ -770,33 +770,6 @@ fn wasm_tracing_should_work(wasm_method: WasmExecutionMethod) {
assert_eq!(len, 2);
}
test_wasm_execution!(spawning_runtime_instance_should_work);
fn spawning_runtime_instance_should_work(wasm_method: WasmExecutionMethod) {
let mut ext = TestExternalities::default();
let mut ext = ext.ext();
call_in_wasm("test_spawn", &[], wasm_method, &mut ext).unwrap();
}
test_wasm_execution!(spawning_runtime_instance_nested_should_work);
fn spawning_runtime_instance_nested_should_work(wasm_method: WasmExecutionMethod) {
let mut ext = TestExternalities::default();
let mut ext = ext.ext();
call_in_wasm("test_nested_spawn", &[], wasm_method, &mut ext).unwrap();
}
test_wasm_execution!(panic_in_spawned_instance_panics_on_joining_its_result);
fn panic_in_spawned_instance_panics_on_joining_its_result(wasm_method: WasmExecutionMethod) {
let mut ext = TestExternalities::default();
let mut ext = ext.ext();
let error_result =
call_in_wasm("test_panic_in_spawned", &[], wasm_method, &mut ext).unwrap_err();
assert!(error_result.to_string().contains("Spawned task"));
}
test_wasm_execution!(memory_is_cleared_between_invocations);
fn memory_is_cleared_between_invocations(wasm_method: WasmExecutionMethod) {
// This is based on the code generated by compiling a runtime *without*
substrate/client/executor/src/native_executor.rs
+9 -158
View File
@@ -23,24 +23,18 @@ use crate::{
};
use std::{
collections::HashMap,
marker::PhantomData,
panic::{AssertUnwindSafe, UnwindSafe},
path::PathBuf,
sync::{
atomic::{AtomicU64, Ordering},
mpsc, Arc,
},
sync::Arc,
};
use codec::Encode;
use sc_executor_common::{
runtime_blob::RuntimeBlob,
wasm_runtime::{AllocationStats, InvokeMethod, WasmInstance, WasmModule},
wasm_runtime::{AllocationStats, WasmInstance, WasmModule},
};
use sp_core::traits::{CodeExecutor, Externalities, RuntimeCode, RuntimeSpawn, RuntimeSpawnExt};
use sp_externalities::ExternalitiesExt as _;
use sp_tasks::new_async_externalities;
use sp_core::traits::{CodeExecutor, Externalities, RuntimeCode};
use sp_version::{GetNativeVersion, NativeVersion, RuntimeVersion};
use sp_wasm_interface::{ExtendedHostFunctions, HostFunctions};
@@ -277,11 +271,9 @@ where
let mut instance = AssertUnwindSafe(instance);
let mut ext = AssertUnwindSafe(ext);
let module = AssertUnwindSafe(module);
let mut allocation_stats_out = AssertUnwindSafe(allocation_stats_out);
with_externalities_safe(&mut **ext, move || {
preregister_builtin_ext(module.clone());
let (result, allocation_stats) =
instance.call_with_allocation_stats(export_name.into(), call_data);
**allocation_stats_out = allocation_stats;
@@ -349,16 +341,10 @@ where
"Executing function",
);
let result = self.with_instance(
runtime_code,
ext,
|module, mut instance, _onchain_version, mut ext| {
with_externalities_safe(&mut **ext, move || {
preregister_builtin_ext(module.clone());
instance.call_export(method, data)
})
},
);
let result =
self.with_instance(runtime_code, ext, |_, mut instance, _onchain_version, mut ext| {
with_externalities_safe(&mut **ext, move || instance.call_export(method, data))
});
(result, false)
}
}
@@ -451,138 +437,6 @@ impl<D: NativeExecutionDispatch> GetNativeVersion for NativeElseWasmExecutor<D>
}
}
/// Helper inner struct to implement `RuntimeSpawn` extension.
pub struct RuntimeInstanceSpawn {
module: Arc<dyn WasmModule>,
tasks: parking_lot::Mutex<HashMap<u64, mpsc::Receiver<Vec<u8>>>>,
counter: AtomicU64,
scheduler: Box<dyn sp_core::traits::SpawnNamed>,
}
impl RuntimeSpawn for RuntimeInstanceSpawn {
fn spawn_call(&self, dispatcher_ref: u32, func: u32, data: Vec<u8>) -> u64 {
let new_handle = self.counter.fetch_add(1, Ordering::Relaxed);
let (sender, receiver) = mpsc::channel();
self.tasks.lock().insert(new_handle, receiver);
let module = self.module.clone();
let scheduler = self.scheduler.clone();
self.scheduler.spawn(
"executor-extra-runtime-instance",
None,
Box::pin(async move {
let module = AssertUnwindSafe(module);
let async_ext = match new_async_externalities(scheduler.clone()) {
Ok(val) => val,
Err(e) => {
tracing::error!(
target: "executor",
error = %e,
"Failed to setup externalities for async context.",
);
// This will drop sender and receiver end will panic
return
},
};
let mut async_ext = match async_ext.with_runtime_spawn(Box::new(
RuntimeInstanceSpawn::new(module.clone(), scheduler),
)) {
Ok(val) => val,
Err(e) => {
tracing::error!(
target: "executor",
error = %e,
"Failed to setup runtime extension for async externalities",
);
// This will drop sender and receiver end will panic
return
},
};
let result = with_externalities_safe(&mut async_ext, move || {
// FIXME: Should be refactored to shared "instance factory".
// Instantiating wasm here every time is suboptimal at the moment, shared
// pool of instances should be used.
//
// https://github.com/paritytech/substrate/issues/7354
let mut instance = match module.new_instance() {
Ok(instance) => instance,
Err(error) => {
panic!("failed to create new instance from module: {}", error)
},
};
match instance
.call(InvokeMethod::TableWithWrapper { dispatcher_ref, func }, &data[..])
{
Ok(result) => result,
Err(error) => panic!("failed to invoke instance: {}", error),
}
});
match result {
Ok(output) => {
let _ = sender.send(output);
},
Err(error) => {
// If execution is panicked, the `join` in the original runtime code will
// panic as well, since the sender is dropped without sending anything.
tracing::error!(error = %error, "Call error in spawned task");
},
}
}),
);
new_handle
}
fn join(&self, handle: u64) -> Vec<u8> {
let receiver = self.tasks.lock().remove(&handle).expect("No task for the handle");
receiver.recv().expect("Spawned task panicked for the handle")
}
}
impl RuntimeInstanceSpawn {
pub fn new(
module: Arc<dyn WasmModule>,
scheduler: Box<dyn sp_core::traits::SpawnNamed>,
) -> Self {
Self { module, scheduler, counter: 0.into(), tasks: HashMap::new().into() }
}
fn with_externalities_and_module(
module: Arc<dyn WasmModule>,
mut ext: &mut dyn Externalities,
) -> Option<Self> {
ext.extension::<sp_core::traits::TaskExecutorExt>()
.map(move |task_ext| Self::new(module, task_ext.clone()))
}
}
/// Pre-registers the built-in extensions to the currently effective externalities.
///
/// Meant to be called each time before calling into the runtime.
fn preregister_builtin_ext(module: Arc<dyn WasmModule>) {
sp_externalities::with_externalities(move |mut ext| {
if let Some(runtime_spawn) =
RuntimeInstanceSpawn::with_externalities_and_module(module, ext)
{
if let Err(e) = ext.register_extension(RuntimeSpawnExt(Box::new(runtime_spawn))) {
tracing::trace!(
target: "executor",
error = ?e,
"Failed to register `RuntimeSpawnExt` instance on externalities",
)
}
}
});
}
impl<D: NativeExecutionDispatch + 'static> CodeExecutor for NativeElseWasmExecutor<D> {
type Error = Error;
@@ -604,7 +458,7 @@ impl<D: NativeExecutionDispatch + 'static> CodeExecutor for NativeElseWasmExecut
let result = self.wasm.with_instance(
runtime_code,
ext,
|module, mut instance, onchain_version, mut ext| {
|_, mut instance, onchain_version, mut ext| {
let onchain_version =
onchain_version.ok_or_else(|| Error::ApiError("Unknown version".into()))?;
@@ -632,10 +486,7 @@ impl<D: NativeExecutionDispatch + 'static> CodeExecutor for NativeElseWasmExecut
);
}
with_externalities_safe(&mut **ext, move || {
preregister_builtin_ext(module.clone());
instance.call_export(method, data)
})
with_externalities_safe(&mut **ext, move || instance.call_export(method, data))
}
},
);
substrate/client/executor/wasmtime/src/runtime.rs
-3
View File
@@ -395,9 +395,6 @@ fn common_config(semantics: &Semantics) -> std::result::Result<wasmtime::Config,
// This determines how many instances of the module can be
// instantiated in parallel from the same `Module`.
//
// This includes nested instances spawned with `sp_tasks::spawn`
// from *within* the runtime.
count: 32,
},
});
substrate/frame/examples/parallel/Cargo.toml
-38
View File
@@ -1,38 +0,0 @@
[package]
name = "pallet-example-parallel"
version = "3.0.0-dev"
authors = ["Parity Technologies <admin@parity.io>"]
edition = "2021"
license = "Unlicense"
homepage = "https://substrate.io"
repository = "https://github.com/paritytech/substrate/"
description = "FRAME example pallet using runtime worker threads"
[package.metadata.docs.rs]
targets = ["x86_64-unknown-linux-gnu"]
[dependencies]
codec = { package = "parity-scale-codec", version = "3.0.0", default-features = false }
scale-info = { version = "2.1.1", default-features = false, features = ["derive"] }
frame-support = { version = "4.0.0-dev", default-features = false, path = "../../support" }
frame-system = { version = "4.0.0-dev", default-features = false, path = "../../system" }
sp-core = { version = "6.0.0", default-features = false, path = "../../../primitives/core" }
sp-io = { version = "6.0.0", default-features = false, path = "../../../primitives/io" }
sp-runtime = { version = "6.0.0", default-features = false, path = "../../../primitives/runtime" }
sp-std = { version = "4.0.0", default-features = false, path = "../../../primitives/std" }
sp-tasks = { version = "4.0.0-dev", default-features = false, path = "../../../primitives/tasks" }
[features]
default = ["std"]
std = [
"codec/std",
"frame-support/std",
"frame-system/std",
"scale-info/std",
"sp-core/std",
"sp-io/std",
"sp-runtime/std",
"sp-std/std",
"sp-tasks/std",
]
try-runtime = ["frame-support/try-runtime"]
substrate/frame/examples/parallel/README.md
-7
View File
@@ -1,7 +0,0 @@
<!-- markdown-link-check-disable -->
# Parallel Tasks Example Pallet
This example pallet demonstrates parallelizing validation of the enlisted participants (see
`enlist_participants` dispatch).
**This pallet serves as an example and is not meant to be used in production.**
substrate/frame/examples/parallel/src/lib.rs
-148
View File
@@ -1,148 +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.
//! # Parallel Tasks Example Pallet
//!
//! This example pallet demonstrates parallelizing validation of the enlisted participants
//! (see `enlist_participants` dispatch).
//!
//! **This pallet serves as an example and is not meant to be used in production.**
#![cfg_attr(not(feature = "std"), no_std)]
use sp_runtime::RuntimeDebug;
use codec::{Decode, Encode};
use sp_std::vec::Vec;
#[cfg(test)]
mod tests;
pub use pallet::*;
#[frame_support::pallet]
pub mod pallet {
use super::*;
use frame_support::pallet_prelude::*;
use frame_system::pallet_prelude::*;
#[pallet::config]
pub trait Config: frame_system::Config {}
#[pallet::pallet]
#[pallet::generate_store(pub(super) trait Store)]
#[pallet::without_storage_info]
pub struct Pallet<T>(_);
/// A public part of the pallet.
#[pallet::call]
impl<T: Config> Pallet<T> {
/// Get the new event running.
#[pallet::weight(0)]
pub fn run_event(origin: OriginFor<T>, id: Vec<u8>) -> DispatchResultWithPostInfo {
let _ = ensure_signed(origin)?;
<Participants<T>>::kill();
<CurrentEventId<T>>::mutate(move |event_id| *event_id = id);
Ok(().into())
}
/// Submit list of participants to the current event.
///
/// The example utilizes parallel execution by checking half of the
/// signatures in spawned task.
#[pallet::weight(0)]
pub fn enlist_participants(
origin: OriginFor<T>,
participants: Vec<EnlistedParticipant>,
) -> DispatchResultWithPostInfo {
let _ = ensure_signed(origin)?;
if validate_participants_parallel(&<CurrentEventId<T>>::get(), &participants[..]) {
for participant in participants {
<Participants<T>>::append(participant.account);
}
}
Ok(().into())
}
}
/// A vector of current participants
///
/// To enlist someone to participate, signed payload should be
/// sent to `enlist`.
#[pallet::storage]
#[pallet::getter(fn participants)]
pub(super) type Participants<T: Config> = StorageValue<_, Vec<Vec<u8>>, ValueQuery>;
/// Current event id to enlist participants to.
#[pallet::storage]
#[pallet::getter(fn get_current_event_id)]
pub(super) type CurrentEventId<T: Config> = StorageValue<_, Vec<u8>, ValueQuery>;
}
/// Request to enlist participant.
#[derive(Encode, Decode, Clone, PartialEq, Eq, RuntimeDebug, scale_info::TypeInfo)]
pub struct EnlistedParticipant {
pub account: Vec<u8>,
pub signature: Vec<u8>,
}
impl EnlistedParticipant {
fn verify(&self, event_id: &[u8]) -> bool {
use sp_core::ByteArray;
use sp_runtime::traits::Verify;
match sp_core::sr25519::Signature::try_from(&self.signature[..]) {
Ok(signature) => match sp_core::sr25519::Public::from_slice(self.account.as_ref()) {
Err(()) => false,
Ok(signer) => signature.verify(event_id, &signer),
},
_ => false,
}
}
}
fn validate_participants_parallel(event_id: &[u8], participants: &[EnlistedParticipant]) -> bool {
fn spawn_verify(data: Vec<u8>) -> Vec<u8> {
let stream = &mut &data[..];
let event_id = Vec::<u8>::decode(stream).expect("Failed to decode");
let participants = Vec::<EnlistedParticipant>::decode(stream).expect("Failed to decode");
for participant in participants {
if !participant.verify(&event_id) {
return false.encode()
}
}
true.encode()
}
let mut async_payload = Vec::new();
event_id.encode_to(&mut async_payload);
participants[..participants.len() / 2].encode_to(&mut async_payload);
let handle = sp_tasks::spawn(spawn_verify, async_payload);
let mut result = true;
for participant in &participants[participants.len() / 2 + 1..] {
if !participant.verify(event_id) {
result = false;
break
}
}
bool::decode(&mut &handle.join()[..]).expect("Failed to decode result") && result
}
substrate/frame/examples/parallel/src/tests.rs
-146
View File
@@ -1,146 +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.
use crate::{self as pallet_example_parallel, *};
use frame_support::parameter_types;
use sp_core::H256;
use sp_runtime::{
testing::Header,
traits::{BlakeTwo256, IdentityLookup},
Perbill,
};
type UncheckedExtrinsic = frame_system::mocking::MockUncheckedExtrinsic<Test>;
type Block = frame_system::mocking::MockBlock<Test>;
frame_support::construct_runtime!(
pub enum Test where
Block = Block,
NodeBlock = Block,
UncheckedExtrinsic = UncheckedExtrinsic,
{
System: frame_system::{Pallet, Call, Config, Storage, Event<T>},
Example: pallet_example_parallel::{Pallet, Call, Storage},
}
);
parameter_types! {
pub const AvailableBlockRatio: Perbill = Perbill::one();
}
impl frame_system::Config for Test {
type BaseCallFilter = frame_support::traits::Everything;
type RuntimeOrigin = RuntimeOrigin;
type RuntimeCall = RuntimeCall;
type PalletInfo = PalletInfo;
type Index = u64;
type BlockNumber = u64;
type Hash = H256;
type Hashing = BlakeTwo256;
type AccountId = sp_core::sr25519::Public;
type Lookup = IdentityLookup<Self::AccountId>;
type Header = Header;
type RuntimeEvent = RuntimeEvent;
type BlockHashCount = frame_support::traits::ConstU64<250>;
type DbWeight = ();
type BlockWeights = ();
type BlockLength = ();
type Version = ();
type AccountData = ();
type OnNewAccount = ();
type OnKilledAccount = ();
type SystemWeightInfo = ();
type SS58Prefix = ();
type OnSetCode = ();
type MaxConsumers = frame_support::traits::ConstU32<16>;
}
impl Config for Test {}
fn test_pub(n: u8) -> sp_core::sr25519::Public {
sp_core::sr25519::Public::from_raw([n; 32])
}
fn test_origin(n: u8) -> RuntimeOrigin {
RuntimeOrigin::signed(test_pub(n))
}
#[test]
fn it_can_enlist() {
use sp_core::Pair;
sp_io::TestExternalities::default().execute_with(|| {
let (pair1, _) = sp_core::sr25519::Pair::generate();
let (pair2, _) = sp_core::sr25519::Pair::generate();
let event_name = b"test";
Example::run_event(test_origin(1), event_name.to_vec()).expect("Failed to enlist");
let participants = vec![
EnlistedParticipant {
account: pair1.public().to_vec(),
signature: AsRef::<[u8]>::as_ref(&pair1.sign(event_name)).to_vec(),
},
EnlistedParticipant {
account: pair2.public().to_vec(),
signature: AsRef::<[u8]>::as_ref(&pair2.sign(event_name)).to_vec(),
},
];
Example::enlist_participants(RuntimeOrigin::signed(test_pub(1)), participants)
.expect("Failed to enlist");
assert_eq!(Example::participants().len(), 2);
});
}
#[test]
fn one_wrong_will_not_enlist_anyone() {
use sp_core::Pair;
sp_io::TestExternalities::default().execute_with(|| {
let (pair1, _) = sp_core::sr25519::Pair::generate();
let (pair2, _) = sp_core::sr25519::Pair::generate();
let (pair3, _) = sp_core::sr25519::Pair::generate();
let event_name = b"test";
Example::run_event(test_origin(1), event_name.to_vec()).expect("Failed to enlist");
let participants = vec![
EnlistedParticipant {
account: pair1.public().to_vec(),
signature: AsRef::<[u8]>::as_ref(&pair1.sign(event_name)).to_vec(),
},
EnlistedParticipant {
account: pair2.public().to_vec(),
signature: AsRef::<[u8]>::as_ref(&pair2.sign(event_name)).to_vec(),
},
// signing wrong event
EnlistedParticipant {
account: pair3.public().to_vec(),
signature: AsRef::<[u8]>::as_ref(&pair3.sign(&[])).to_vec(),
},
];
Example::enlist_participants(test_origin(1), participants).expect("Failed to enlist");
assert_eq!(Example::participants().len(), 0);
});
}
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");
}
}