feat: initialize Kurdistan SDK - independent fork of Polkadot SDK
This commit is contained in:
@@ -0,0 +1,256 @@
|
||||
// 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/>.
|
||||
|
||||
use pezkuwi_sdk::*;
|
||||
|
||||
use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
|
||||
|
||||
use kitchensink_runtime::{constants::currency::*, BalancesCall};
|
||||
use node_cli::service::{create_extrinsic, FullClient};
|
||||
use pezkuwi_sdk::sc_service::config::{ExecutorConfiguration, RpcConfiguration};
|
||||
use sc_block_builder::{BlockBuilderBuilder, BuiltBlock};
|
||||
use sc_consensus::{
|
||||
block_import::{BlockImportParams, ForkChoiceStrategy},
|
||||
BlockImport, StateAction,
|
||||
};
|
||||
use sc_service::{
|
||||
config::{
|
||||
BlocksPruning, DatabaseSource, KeystoreConfig, NetworkConfiguration, OffchainWorkerConfig,
|
||||
PruningMode, RpcBatchRequestConfig, WasmExecutionMethod, WasmtimeInstantiationStrategy,
|
||||
},
|
||||
BasePath, Configuration, Role,
|
||||
};
|
||||
use sp_blockchain::{ApplyExtrinsicFailed::Validity, Error::ApplyExtrinsicFailed};
|
||||
use sp_consensus::BlockOrigin;
|
||||
use sp_keyring::Sr25519Keyring;
|
||||
use sp_runtime::{
|
||||
generic,
|
||||
transaction_validity::{InvalidTransaction, TransactionValidityError},
|
||||
AccountId32, MultiAddress, OpaqueExtrinsic,
|
||||
};
|
||||
use staging_node_cli as node_cli;
|
||||
use tokio::runtime::Handle;
|
||||
|
||||
fn new_node(tokio_handle: Handle) -> node_cli::service::NewFullBase {
|
||||
let base_path = BasePath::new_temp_dir()
|
||||
.expect("getting the base path of a temporary path doesn't fail; qed");
|
||||
let root = base_path.path().to_path_buf();
|
||||
|
||||
let network_config = NetworkConfiguration::new(
|
||||
Sr25519Keyring::Alice.to_seed(),
|
||||
"network/test/0.1",
|
||||
Default::default(),
|
||||
None,
|
||||
);
|
||||
|
||||
let spec = Box::new(node_cli::chain_spec::development_config());
|
||||
|
||||
let config = Configuration {
|
||||
impl_name: "BenchmarkImpl".into(),
|
||||
impl_version: "1.0".into(),
|
||||
// We don't use the authority role since that would start producing blocks
|
||||
// in the background which would mess with our benchmark.
|
||||
role: Role::Full,
|
||||
tokio_handle,
|
||||
transaction_pool: Default::default(),
|
||||
network: network_config,
|
||||
keystore: KeystoreConfig::InMemory,
|
||||
database: DatabaseSource::RocksDb { path: root.join("db"), cache_size: 128 },
|
||||
trie_cache_maximum_size: Some(64 * 1024 * 1024),
|
||||
warm_up_trie_cache: None,
|
||||
state_pruning: Some(PruningMode::ArchiveAll),
|
||||
blocks_pruning: BlocksPruning::KeepAll,
|
||||
chain_spec: spec,
|
||||
executor: ExecutorConfiguration {
|
||||
wasm_method: WasmExecutionMethod::Compiled {
|
||||
instantiation_strategy: WasmtimeInstantiationStrategy::PoolingCopyOnWrite,
|
||||
},
|
||||
..ExecutorConfiguration::default()
|
||||
},
|
||||
rpc: RpcConfiguration {
|
||||
addr: None,
|
||||
max_connections: Default::default(),
|
||||
cors: None,
|
||||
methods: Default::default(),
|
||||
max_request_size: Default::default(),
|
||||
max_response_size: Default::default(),
|
||||
id_provider: Default::default(),
|
||||
max_subs_per_conn: Default::default(),
|
||||
port: 9944,
|
||||
message_buffer_capacity: Default::default(),
|
||||
batch_config: RpcBatchRequestConfig::Unlimited,
|
||||
rate_limit: None,
|
||||
rate_limit_whitelisted_ips: Default::default(),
|
||||
rate_limit_trust_proxy_headers: Default::default(),
|
||||
request_logger_limit: 1024,
|
||||
},
|
||||
prometheus_config: None,
|
||||
telemetry_endpoints: None,
|
||||
offchain_worker: OffchainWorkerConfig { enabled: true, indexing_enabled: false },
|
||||
force_authoring: false,
|
||||
disable_grandpa: false,
|
||||
dev_key_seed: Some(Sr25519Keyring::Alice.to_seed()),
|
||||
tracing_targets: None,
|
||||
tracing_receiver: Default::default(),
|
||||
announce_block: true,
|
||||
data_path: base_path.path().into(),
|
||||
base_path,
|
||||
wasm_runtime_overrides: None,
|
||||
};
|
||||
|
||||
node_cli::service::new_full_base::<sc_network::NetworkWorker<_, _>>(
|
||||
config,
|
||||
None,
|
||||
false,
|
||||
|_, _| (),
|
||||
)
|
||||
.expect("creating a full node doesn't fail")
|
||||
}
|
||||
|
||||
fn extrinsic_set_time(now: u64) -> OpaqueExtrinsic {
|
||||
let utx: kitchensink_runtime::UncheckedExtrinsic = generic::UncheckedExtrinsic::new_bare(
|
||||
kitchensink_runtime::RuntimeCall::Timestamp(pallet_timestamp::Call::set { now }),
|
||||
)
|
||||
.into();
|
||||
utx.into()
|
||||
}
|
||||
|
||||
fn import_block(client: &FullClient, built: BuiltBlock<node_primitives::Block>) {
|
||||
let mut params = BlockImportParams::new(BlockOrigin::File, built.block.header);
|
||||
params.state_action =
|
||||
StateAction::ApplyChanges(sc_consensus::StorageChanges::Changes(built.storage_changes));
|
||||
params.fork_choice = Some(ForkChoiceStrategy::LongestChain);
|
||||
futures::executor::block_on(client.import_block(params))
|
||||
.expect("importing a block doesn't fail");
|
||||
}
|
||||
|
||||
fn prepare_benchmark(client: &FullClient) -> (usize, Vec<OpaqueExtrinsic>) {
|
||||
const MINIMUM_PERIOD_FOR_BLOCKS: u64 = 1500;
|
||||
|
||||
let mut max_transfer_count = 0;
|
||||
let mut extrinsics = Vec::new();
|
||||
let mut block_builder = BlockBuilderBuilder::new(client)
|
||||
.on_parent_block(client.chain_info().best_hash)
|
||||
.with_parent_block_number(client.chain_info().best_number)
|
||||
.build()
|
||||
.unwrap();
|
||||
|
||||
// Every block needs one timestamp extrinsic.
|
||||
let extrinsic_set_time = extrinsic_set_time(1 + MINIMUM_PERIOD_FOR_BLOCKS);
|
||||
block_builder.push(extrinsic_set_time.clone()).unwrap();
|
||||
extrinsics.push(extrinsic_set_time);
|
||||
|
||||
// Creating those is surprisingly costly, so let's only do it once and later just `clone` them.
|
||||
let src = Sr25519Keyring::Alice.pair();
|
||||
let dst: MultiAddress<AccountId32, u32> = Sr25519Keyring::Bob.to_account_id().into();
|
||||
|
||||
// Add as many transfer extrinsics as possible into a single block.
|
||||
for nonce in 0.. {
|
||||
let extrinsic: OpaqueExtrinsic = create_extrinsic(
|
||||
client,
|
||||
src.clone(),
|
||||
BalancesCall::transfer_allow_death { dest: dst.clone(), value: 1 * DOLLARS },
|
||||
Some(nonce),
|
||||
)
|
||||
.into();
|
||||
|
||||
match block_builder.push(extrinsic.clone()) {
|
||||
Ok(_) => {},
|
||||
Err(ApplyExtrinsicFailed(Validity(TransactionValidityError::Invalid(
|
||||
InvalidTransaction::ExhaustsResources,
|
||||
)))) => break,
|
||||
Err(error) => panic!("{}", error),
|
||||
}
|
||||
|
||||
extrinsics.push(extrinsic);
|
||||
max_transfer_count += 1;
|
||||
}
|
||||
|
||||
(max_transfer_count, extrinsics)
|
||||
}
|
||||
|
||||
fn block_production(c: &mut Criterion) {
|
||||
sp_tracing::try_init_simple();
|
||||
|
||||
let runtime = tokio::runtime::Runtime::new().expect("creating tokio runtime doesn't fail; qed");
|
||||
let tokio_handle = runtime.handle().clone();
|
||||
|
||||
let node = new_node(tokio_handle.clone());
|
||||
let client = &*node.client;
|
||||
|
||||
// Building the very first block is around ~30x slower than any subsequent one,
|
||||
// so let's make sure it's built and imported before we benchmark anything.
|
||||
let mut block_builder = BlockBuilderBuilder::new(client)
|
||||
.on_parent_block(client.chain_info().best_hash)
|
||||
.with_parent_block_number(client.chain_info().best_number)
|
||||
.build()
|
||||
.unwrap();
|
||||
block_builder.push(extrinsic_set_time(1)).unwrap();
|
||||
import_block(client, block_builder.build().unwrap());
|
||||
|
||||
let (max_transfer_count, extrinsics) = prepare_benchmark(&client);
|
||||
log::info!("Maximum transfer count: {}", max_transfer_count);
|
||||
|
||||
let mut group = c.benchmark_group("Block production");
|
||||
|
||||
group.sample_size(10);
|
||||
group.throughput(Throughput::Elements(max_transfer_count as u64));
|
||||
|
||||
let chain = client.chain_info();
|
||||
let best_hash = chain.best_hash;
|
||||
let best_number = chain.best_number;
|
||||
|
||||
group.bench_function(format!("{} transfers (no proof)", max_transfer_count), |b| {
|
||||
b.iter_batched(
|
||||
|| extrinsics.clone(),
|
||||
|extrinsics| {
|
||||
let mut block_builder = BlockBuilderBuilder::new(client)
|
||||
.on_parent_block(best_hash)
|
||||
.with_parent_block_number(best_number)
|
||||
.build()
|
||||
.unwrap();
|
||||
for extrinsic in extrinsics {
|
||||
block_builder.push(extrinsic).unwrap();
|
||||
}
|
||||
block_builder.build().unwrap()
|
||||
},
|
||||
BatchSize::SmallInput,
|
||||
)
|
||||
});
|
||||
|
||||
group.bench_function(format!("{} transfers (with proof)", max_transfer_count), |b| {
|
||||
b.iter_batched(
|
||||
|| extrinsics.clone(),
|
||||
|extrinsics| {
|
||||
let mut block_builder = BlockBuilderBuilder::new(client)
|
||||
.on_parent_block(best_hash)
|
||||
.with_parent_block_number(best_number)
|
||||
.build()
|
||||
.unwrap();
|
||||
for extrinsic in extrinsics {
|
||||
block_builder.push(extrinsic).unwrap();
|
||||
}
|
||||
block_builder.build().unwrap()
|
||||
},
|
||||
BatchSize::SmallInput,
|
||||
)
|
||||
});
|
||||
}
|
||||
|
||||
criterion_group!(benches, block_production);
|
||||
criterion_main!(benches);
|
||||
@@ -0,0 +1,206 @@
|
||||
// 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/>.
|
||||
|
||||
use pezkuwi_sdk::*;
|
||||
|
||||
use codec::{Decode, Encode};
|
||||
use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
|
||||
use frame_support::Hashable;
|
||||
use kitchensink_runtime::{
|
||||
constants::currency::*, Block, BuildStorage, CheckedExtrinsic, Header, RuntimeCall,
|
||||
RuntimeGenesisConfig, UncheckedExtrinsic,
|
||||
};
|
||||
use node_primitives::{BlockNumber, Hash};
|
||||
use node_testing::keyring::*;
|
||||
use sc_executor::{Externalities, RuntimeVersionOf};
|
||||
use sp_core::{
|
||||
storage::well_known_keys,
|
||||
traits::{CallContext, CodeExecutor, RuntimeCode},
|
||||
};
|
||||
use sp_runtime::{generic::ExtrinsicFormat, traits::BlakeTwo256};
|
||||
use sp_state_machine::TestExternalities as CoreTestExternalities;
|
||||
use staging_node_cli::service::RuntimeExecutor;
|
||||
|
||||
criterion_group!(benches, bench_execute_block);
|
||||
criterion_main!(benches);
|
||||
|
||||
/// The wasm runtime code.
|
||||
pub fn compact_code_unwrap() -> &'static [u8] {
|
||||
kitchensink_runtime::WASM_BINARY.expect(
|
||||
"Development wasm binary is not available. Testing is only supported with the flag \
|
||||
disabled.",
|
||||
)
|
||||
}
|
||||
|
||||
const GENESIS_HASH: [u8; 32] = [69u8; 32];
|
||||
|
||||
const TRANSACTION_VERSION: u32 = kitchensink_runtime::VERSION.transaction_version;
|
||||
|
||||
const SPEC_VERSION: u32 = kitchensink_runtime::VERSION.spec_version;
|
||||
|
||||
const HEAP_PAGES: u64 = 20;
|
||||
|
||||
type TestExternalities<H> = CoreTestExternalities<H>;
|
||||
|
||||
fn sign(xt: CheckedExtrinsic) -> UncheckedExtrinsic {
|
||||
node_testing::keyring::sign(xt, SPEC_VERSION, TRANSACTION_VERSION, GENESIS_HASH, None)
|
||||
}
|
||||
|
||||
fn new_test_ext(genesis_config: &RuntimeGenesisConfig) -> TestExternalities<BlakeTwo256> {
|
||||
let mut test_ext = TestExternalities::new_with_code(
|
||||
compact_code_unwrap(),
|
||||
genesis_config.build_storage().unwrap(),
|
||||
);
|
||||
test_ext
|
||||
.ext()
|
||||
.place_storage(well_known_keys::HEAP_PAGES.to_vec(), Some(HEAP_PAGES.encode()));
|
||||
test_ext
|
||||
}
|
||||
|
||||
fn construct_block<E: Externalities>(
|
||||
executor: &RuntimeExecutor,
|
||||
ext: &mut E,
|
||||
number: BlockNumber,
|
||||
parent_hash: Hash,
|
||||
extrinsics: Vec<CheckedExtrinsic>,
|
||||
) -> (Vec<u8>, Hash) {
|
||||
use sp_trie::{LayoutV0, TrieConfiguration};
|
||||
|
||||
// sign extrinsics.
|
||||
let extrinsics = extrinsics.into_iter().map(sign).collect::<Vec<_>>();
|
||||
|
||||
// calculate the header fields that we can.
|
||||
let extrinsics_root =
|
||||
LayoutV0::<BlakeTwo256>::ordered_trie_root(extrinsics.iter().map(Encode::encode))
|
||||
.to_fixed_bytes()
|
||||
.into();
|
||||
|
||||
let header = Header {
|
||||
parent_hash,
|
||||
number,
|
||||
extrinsics_root,
|
||||
state_root: Default::default(),
|
||||
digest: Default::default(),
|
||||
};
|
||||
|
||||
let runtime_code = RuntimeCode {
|
||||
code_fetcher: &sp_core::traits::WrappedRuntimeCode(compact_code_unwrap().into()),
|
||||
hash: vec![1, 2, 3],
|
||||
heap_pages: None,
|
||||
};
|
||||
|
||||
// execute the block to get the real header.
|
||||
executor
|
||||
.call(ext, &runtime_code, "Core_initialize_block", &header.encode(), CallContext::Offchain)
|
||||
.0
|
||||
.unwrap();
|
||||
|
||||
for i in extrinsics.iter() {
|
||||
executor
|
||||
.call(
|
||||
ext,
|
||||
&runtime_code,
|
||||
"BlockBuilder_apply_extrinsic",
|
||||
&i.encode(),
|
||||
CallContext::Offchain,
|
||||
)
|
||||
.0
|
||||
.unwrap();
|
||||
}
|
||||
|
||||
let header = Header::decode(
|
||||
&mut &executor
|
||||
.call(
|
||||
ext,
|
||||
&runtime_code,
|
||||
"BlockBuilder_finalize_block",
|
||||
&[0u8; 0],
|
||||
CallContext::Offchain,
|
||||
)
|
||||
.0
|
||||
.unwrap()[..],
|
||||
)
|
||||
.unwrap();
|
||||
|
||||
let hash = header.blake2_256();
|
||||
(Block { header, extrinsics }.encode(), hash.into())
|
||||
}
|
||||
|
||||
fn test_blocks(
|
||||
genesis_config: &RuntimeGenesisConfig,
|
||||
executor: &RuntimeExecutor,
|
||||
) -> Vec<(Vec<u8>, Hash)> {
|
||||
let mut test_ext = new_test_ext(genesis_config);
|
||||
let mut block1_extrinsics = vec![CheckedExtrinsic {
|
||||
format: ExtrinsicFormat::Bare,
|
||||
function: RuntimeCall::Timestamp(pallet_timestamp::Call::set { now: 0 }),
|
||||
}];
|
||||
block1_extrinsics.extend((0..20).map(|i| CheckedExtrinsic {
|
||||
format: ExtrinsicFormat::Signed(alice(), tx_ext(i, 0)),
|
||||
function: RuntimeCall::Balances(pallet_balances::Call::transfer_allow_death {
|
||||
dest: bob().into(),
|
||||
value: 1 * DOLLARS,
|
||||
}),
|
||||
}));
|
||||
let block1 =
|
||||
construct_block(executor, &mut test_ext.ext(), 1, GENESIS_HASH.into(), block1_extrinsics);
|
||||
|
||||
vec![block1]
|
||||
}
|
||||
|
||||
fn bench_execute_block(c: &mut Criterion) {
|
||||
let mut group = c.benchmark_group("execute blocks");
|
||||
|
||||
group.bench_function("wasm", |b| {
|
||||
let genesis_config = node_testing::genesis::config();
|
||||
|
||||
let executor = RuntimeExecutor::builder().build();
|
||||
let runtime_code = RuntimeCode {
|
||||
code_fetcher: &sp_core::traits::WrappedRuntimeCode(compact_code_unwrap().into()),
|
||||
hash: vec![1, 2, 3],
|
||||
heap_pages: None,
|
||||
};
|
||||
|
||||
// Get the runtime version to initialize the runtimes cache.
|
||||
{
|
||||
let mut test_ext = new_test_ext(&genesis_config);
|
||||
executor.runtime_version(&mut test_ext.ext(), &runtime_code).unwrap();
|
||||
}
|
||||
|
||||
let blocks = test_blocks(&genesis_config, &executor);
|
||||
|
||||
b.iter_batched_ref(
|
||||
|| new_test_ext(&genesis_config),
|
||||
|test_ext| {
|
||||
for block in blocks.iter() {
|
||||
executor
|
||||
.call(
|
||||
&mut test_ext.ext(),
|
||||
&runtime_code,
|
||||
"Core_execute_block",
|
||||
&block.0,
|
||||
CallContext::Offchain,
|
||||
)
|
||||
.0
|
||||
.unwrap();
|
||||
}
|
||||
},
|
||||
BatchSize::LargeInput,
|
||||
);
|
||||
});
|
||||
}
|
||||
@@ -0,0 +1,275 @@
|
||||
// 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/>.
|
||||
|
||||
use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
|
||||
use futures::{future, StreamExt};
|
||||
use kitchensink_runtime::{constants::currency::*, BalancesCall, SudoCall};
|
||||
use node_cli::service::{create_extrinsic, fetch_nonce, FullClient, TransactionPool};
|
||||
use node_primitives::AccountId;
|
||||
use pezkuwi_sdk::{
|
||||
sc_service::config::{ExecutorConfiguration, RpcConfiguration},
|
||||
sc_transaction_pool_api::TransactionPool as _,
|
||||
*,
|
||||
};
|
||||
use sc_service::{
|
||||
config::{
|
||||
BlocksPruning, DatabaseSource, KeystoreConfig, NetworkConfiguration, OffchainWorkerConfig,
|
||||
PruningMode, RpcBatchRequestConfig, TransactionPoolOptions,
|
||||
},
|
||||
BasePath, Configuration, Role,
|
||||
};
|
||||
use sc_transaction_pool_api::{TransactionSource, TransactionStatus};
|
||||
use sp_core::{crypto::Pair, sr25519};
|
||||
use sp_keyring::Sr25519Keyring;
|
||||
use sp_runtime::OpaqueExtrinsic;
|
||||
use staging_node_cli as node_cli;
|
||||
use tokio::runtime::Handle;
|
||||
|
||||
fn new_node(tokio_handle: Handle) -> node_cli::service::NewFullBase {
|
||||
let base_path = BasePath::new_temp_dir().expect("Creates base path");
|
||||
let root = base_path.path().to_path_buf();
|
||||
|
||||
let network_config = NetworkConfiguration::new(
|
||||
Sr25519Keyring::Alice.to_seed(),
|
||||
"network/test/0.1",
|
||||
Default::default(),
|
||||
None,
|
||||
);
|
||||
|
||||
let spec = Box::new(node_cli::chain_spec::development_config());
|
||||
|
||||
let config = Configuration {
|
||||
impl_name: "BenchmarkImpl".into(),
|
||||
impl_version: "1.0".into(),
|
||||
role: Role::Authority,
|
||||
tokio_handle: tokio_handle.clone(),
|
||||
transaction_pool: TransactionPoolOptions::new_for_benchmarks(),
|
||||
network: network_config,
|
||||
keystore: KeystoreConfig::InMemory,
|
||||
database: DatabaseSource::RocksDb { path: root.join("db"), cache_size: 128 },
|
||||
trie_cache_maximum_size: Some(64 * 1024 * 1024),
|
||||
warm_up_trie_cache: None,
|
||||
state_pruning: Some(PruningMode::ArchiveAll),
|
||||
blocks_pruning: BlocksPruning::KeepAll,
|
||||
chain_spec: spec,
|
||||
executor: ExecutorConfiguration::default(),
|
||||
rpc: RpcConfiguration {
|
||||
addr: None,
|
||||
max_connections: Default::default(),
|
||||
cors: None,
|
||||
methods: Default::default(),
|
||||
max_request_size: Default::default(),
|
||||
max_response_size: Default::default(),
|
||||
id_provider: Default::default(),
|
||||
max_subs_per_conn: Default::default(),
|
||||
port: 9944,
|
||||
message_buffer_capacity: Default::default(),
|
||||
batch_config: RpcBatchRequestConfig::Unlimited,
|
||||
rate_limit: None,
|
||||
rate_limit_whitelisted_ips: Default::default(),
|
||||
rate_limit_trust_proxy_headers: Default::default(),
|
||||
request_logger_limit: 1024,
|
||||
},
|
||||
prometheus_config: None,
|
||||
telemetry_endpoints: None,
|
||||
offchain_worker: OffchainWorkerConfig { enabled: true, indexing_enabled: false },
|
||||
force_authoring: false,
|
||||
disable_grandpa: false,
|
||||
dev_key_seed: Some(Sr25519Keyring::Alice.to_seed()),
|
||||
tracing_targets: None,
|
||||
tracing_receiver: Default::default(),
|
||||
announce_block: true,
|
||||
data_path: base_path.path().into(),
|
||||
base_path,
|
||||
wasm_runtime_overrides: None,
|
||||
};
|
||||
|
||||
tokio_handle.block_on(async move {
|
||||
node_cli::service::new_full_base::<sc_network::NetworkWorker<_, _>>(
|
||||
config,
|
||||
None,
|
||||
false,
|
||||
|_, _| (),
|
||||
)
|
||||
.expect("Creates node")
|
||||
})
|
||||
}
|
||||
|
||||
fn create_accounts(num: usize) -> Vec<sr25519::Pair> {
|
||||
(0..num)
|
||||
.map(|i| {
|
||||
Pair::from_string(&format!("{}/{}", Sr25519Keyring::Alice.to_seed(), i), None)
|
||||
.expect("Creates account pair")
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Create the extrinsics that will initialize the accounts from the sudo account (Alice).
|
||||
///
|
||||
/// `start_nonce` is the current nonce of Alice.
|
||||
fn create_account_extrinsics(
|
||||
client: &FullClient,
|
||||
accounts: &[sr25519::Pair],
|
||||
) -> Vec<OpaqueExtrinsic> {
|
||||
let start_nonce = fetch_nonce(client, Sr25519Keyring::Alice.pair());
|
||||
|
||||
accounts
|
||||
.iter()
|
||||
.enumerate()
|
||||
.flat_map(|(i, a)| {
|
||||
vec![
|
||||
// Reset the nonce by removing any funds
|
||||
create_extrinsic(
|
||||
client,
|
||||
Sr25519Keyring::Alice.pair(),
|
||||
SudoCall::sudo {
|
||||
call: Box::new(
|
||||
BalancesCall::force_set_balance {
|
||||
who: AccountId::from(a.public()).into(),
|
||||
new_free: 0,
|
||||
}
|
||||
.into(),
|
||||
),
|
||||
},
|
||||
Some(start_nonce + (i as u32) * 2),
|
||||
),
|
||||
// Give back funds
|
||||
create_extrinsic(
|
||||
client,
|
||||
Sr25519Keyring::Alice.pair(),
|
||||
SudoCall::sudo {
|
||||
call: Box::new(
|
||||
BalancesCall::force_set_balance {
|
||||
who: AccountId::from(a.public()).into(),
|
||||
new_free: 1_000_000 * DOLLARS,
|
||||
}
|
||||
.into(),
|
||||
),
|
||||
},
|
||||
Some(start_nonce + (i as u32) * 2 + 1),
|
||||
),
|
||||
]
|
||||
})
|
||||
.map(OpaqueExtrinsic::from)
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn create_benchmark_extrinsics(
|
||||
client: &FullClient,
|
||||
accounts: &[sr25519::Pair],
|
||||
extrinsics_per_account: usize,
|
||||
) -> Vec<OpaqueExtrinsic> {
|
||||
accounts
|
||||
.iter()
|
||||
.flat_map(|account| {
|
||||
(0..extrinsics_per_account).map(move |nonce| {
|
||||
create_extrinsic(
|
||||
client,
|
||||
account.clone(),
|
||||
BalancesCall::transfer_allow_death {
|
||||
dest: Sr25519Keyring::Bob.to_account_id().into(),
|
||||
value: 1 * DOLLARS,
|
||||
},
|
||||
Some(nonce as u32),
|
||||
)
|
||||
})
|
||||
})
|
||||
.map(OpaqueExtrinsic::from)
|
||||
.collect()
|
||||
}
|
||||
|
||||
async fn submit_tx_and_wait_for_inclusion(
|
||||
tx_pool: &TransactionPool,
|
||||
tx: OpaqueExtrinsic,
|
||||
client: &FullClient,
|
||||
wait_for_finalized: bool,
|
||||
) {
|
||||
let best_hash = client.chain_info().best_hash;
|
||||
|
||||
let mut watch = tx_pool
|
||||
.submit_and_watch(best_hash, TransactionSource::External, tx.clone())
|
||||
.await
|
||||
.expect("Submits tx to pool")
|
||||
.fuse();
|
||||
|
||||
loop {
|
||||
match watch.select_next_some().await {
|
||||
TransactionStatus::Finalized(_) => break,
|
||||
TransactionStatus::InBlock(_) if !wait_for_finalized => break,
|
||||
_ => {},
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn transaction_pool_benchmarks(c: &mut Criterion) {
|
||||
sp_tracing::try_init_simple();
|
||||
|
||||
let runtime = tokio::runtime::Runtime::new().expect("Creates tokio runtime");
|
||||
let tokio_handle = runtime.handle().clone();
|
||||
|
||||
let node = new_node(tokio_handle.clone());
|
||||
|
||||
let account_num = 10;
|
||||
let extrinsics_per_account = 2000;
|
||||
let accounts = create_accounts(account_num);
|
||||
|
||||
let mut group = c.benchmark_group("Transaction pool");
|
||||
|
||||
group.sample_size(10);
|
||||
group.throughput(Throughput::Elements(account_num as u64 * extrinsics_per_account as u64));
|
||||
|
||||
let mut counter = 1;
|
||||
group.bench_function(
|
||||
format!("{} transfers from {} accounts", account_num * extrinsics_per_account, account_num),
|
||||
move |b| {
|
||||
b.iter_batched(
|
||||
|| {
|
||||
let prepare_extrinsics = create_account_extrinsics(&node.client, &accounts);
|
||||
|
||||
runtime.block_on(future::join_all(prepare_extrinsics.into_iter().map(|tx| {
|
||||
submit_tx_and_wait_for_inclusion(
|
||||
&node.transaction_pool,
|
||||
tx,
|
||||
&node.client,
|
||||
true,
|
||||
)
|
||||
})));
|
||||
|
||||
create_benchmark_extrinsics(&node.client, &accounts, extrinsics_per_account)
|
||||
},
|
||||
|extrinsics| {
|
||||
runtime.block_on(future::join_all(extrinsics.into_iter().map(|tx| {
|
||||
submit_tx_and_wait_for_inclusion(
|
||||
&node.transaction_pool,
|
||||
tx,
|
||||
&node.client,
|
||||
false,
|
||||
)
|
||||
})));
|
||||
|
||||
println!("Finished {}", counter);
|
||||
counter += 1;
|
||||
},
|
||||
BatchSize::SmallInput,
|
||||
)
|
||||
},
|
||||
);
|
||||
}
|
||||
|
||||
criterion_group!(benches, transaction_pool_benchmarks);
|
||||
criterion_main!(benches);
|
||||
Reference in New Issue
Block a user