Prestore block to db before insert to orphan block pool, reduce channel length

Makefile

@@ -125,13 +125,13 @@ check: setup-ckb-test ## Runs all of the compiler's checks.
 build: ## Build binary with release profile.
 	cargo build ${VERBOSE} --release
 
-.PHONY: build-for-profiling-without-debug-symbols
-build-for-profiling-without-debug-symbols: ## Build binary with for profiling without debug symbols.
-	JEMALLOC_SYS_WITH_MALLOC_CONF="prof:true" cargo build ${VERBOSE} --release --features "profiling"
+.PHONY: profiling
+profiling: ## Build binary with for profiling without debug symbols.
+	JEMALLOC_SYS_WITH_MALLOC_CONF="prof:true" cargo build ${VERBOSE} --profile prod --features "with_sentry,with_dns_seeding,profiling"
 
-.PHONY: build-for-profiling
+.PHONY: profiling-with-debug-symbols
 build-for-profiling: ## Build binary with for profiling.
-	devtools/release/make-with-debug-symbols build-for-profiling-without-debug-symbols
+	devtools/release/make-with-debug-symbols profiling
 
 .PHONY: prod
 prod: ## Build binary for production release.

benches/benches/benchmarks/always_success.rs

@@ -32,7 +32,7 @@ fn bench(c: &mut Criterion) {
                         (0..20).for_each(|_| {
                             let block = gen_always_success_block(&mut blocks, &parent, shared2);
                             chain2
-                                .internal_process_block(
+                                .blocking_process_block_with_switch(
                                     Arc::new(block.clone()),
                                     Switch::DISABLE_ALL,
                                 )
@@ -44,7 +44,7 @@ fn bench(c: &mut Criterion) {
                     |(chain, blocks)| {
                         blocks.into_iter().skip(1).for_each(|block| {
                             chain
-                                .process_block(Arc::new(block))
+                                .blocking_process_block(Arc::new(block))
                                 .expect("process block OK");
                         });
                     },
@@ -77,14 +77,14 @@ fn bench(c: &mut Criterion) {
                         (0..5).for_each(|i| {
                             let block = gen_always_success_block(&mut blocks, &parent, shared2);
                             chain2
-                                .internal_process_block(
+                                .blocking_process_block_with_switch(
                                     Arc::new(block.clone()),
                                     Switch::DISABLE_ALL,
                                 )
                                 .expect("process block OK");
                             if i < 2 {
                                 chain3
-                                    .internal_process_block(
+                                    .blocking_process_block_with_switch(
                                         Arc::new(block.clone()),
                                         Switch::DISABLE_ALL,
                                     )
@@ -96,7 +96,7 @@ fn bench(c: &mut Criterion) {
                         (0..2).for_each(|_| {
                             let block = gen_always_success_block(&mut blocks, &parent, shared3);
                             chain3
-                                .internal_process_block(
+                                .blocking_process_block_with_switch(
                                     Arc::new(block.clone()),
                                     Switch::DISABLE_ALL,
                                 )
@@ -110,15 +110,18 @@ fn bench(c: &mut Criterion) {
                             .take(5)
                             .for_each(|block| {
                                 chain1
-                                    .internal_process_block(Arc::new(block), Switch::DISABLE_ALL)
+                                    .blocking_process_block_with_switch(
+                                        Arc::new(block),
+                                        Switch::DISABLE_ALL,
+                                    )
                                     .expect("process block OK");
                             });
                         (chain1.clone(), blocks)
                     },
                     |(chain, blocks)| {
                         blocks.into_iter().skip(6).for_each(|block| {
                             chain
-                                .process_block(Arc::new(block))
+                                .blocking_process_block(Arc::new(block))
                                 .expect("process block OK");
                         });
                     },
@@ -152,11 +155,17 @@ fn bench(c: &mut Criterion) {
                             let block = gen_always_success_block(&mut blocks, &parent, shared2);
                             let arc_block = Arc::new(block.clone());
                             chain2
-                                .internal_process_block(Arc::clone(&arc_block), Switch::DISABLE_ALL)
+                                .blocking_process_block_with_switch(
+                                    Arc::clone(&arc_block),
+                                    Switch::DISABLE_ALL,
+                                )
                                 .expect("process block OK");
                             if i < 2 {
                                 chain3
-                                    .internal_process_block(arc_block, Switch::DISABLE_ALL)
+                                    .blocking_process_block_with_switch(
+                                        arc_block,
+                                        Switch::DISABLE_ALL,
+                                    )
                                     .expect("process block OK");
                             }
                             parent = block;
@@ -165,7 +174,7 @@ fn bench(c: &mut Criterion) {
                         (0..4).for_each(|_| {
                             let block = gen_always_success_block(&mut blocks, &parent, shared3);
                             chain3
-                                .internal_process_block(
+                                .blocking_process_block_with_switch(
                                     Arc::new(block.clone()),
                                     Switch::DISABLE_ALL,
                                 )
@@ -179,15 +188,18 @@ fn bench(c: &mut Criterion) {
                             .take(7)
                             .for_each(|block| {
                                 chain1
-                                    .internal_process_block(Arc::new(block), Switch::DISABLE_ALL)
+                                    .blocking_process_block_with_switch(
+                                        Arc::new(block),
+                                        Switch::DISABLE_ALL,
+                                    )
                                     .expect("process block OK");
                             });
                         (chain1.clone(), blocks)
                     },
                     |(chain, blocks)| {
                         blocks.into_iter().skip(8).for_each(|block| {
                             chain
-                                .process_block(Arc::new(block))
+                                .blocking_process_block(Arc::new(block))
                                 .expect("process block OK");
                         });
                     },

benches/benches/benchmarks/overall.rs

@@ -1,7 +1,7 @@
 use crate::benchmarks::util::{create_2out_transaction, create_secp_tx, secp_cell};
 use ckb_app_config::NetworkConfig;
 use ckb_app_config::{BlockAssemblerConfig, TxPoolConfig};
-use ckb_chain::chain::{ChainController, ChainService};
+use ckb_chain::{start_chain_services, ChainController};
 use ckb_chain_spec::consensus::{ConsensusBuilder, ProposalWindow};
 use ckb_dao_utils::genesis_dao_data;
 use ckb_jsonrpc_types::JsonBytes;
@@ -132,8 +132,7 @@ pub fn setup_chain(txs_size: usize) -> (Shared, ChainController) {
     let network = dummy_network(&shared);
     pack.take_tx_pool_builder().start(network);
 
-    let chain_service = ChainService::new(shared.clone(), pack.take_proposal_table());
-    let chain_controller = chain_service.start(Some("ChainService"));
+    let chain_controller = start_chain_services(pack.take_chain_services_builder());
 
     (shared, chain_controller)
 }
@@ -217,7 +216,9 @@ fn bench(c: &mut Criterion) {
                                 .verify(&block.header())
                                 .expect("header verified");
 
-                            chain.process_block(Arc::new(block)).expect("process_block");
+                            chain
+                                .blocking_process_block(Arc::new(block))
+                                .expect("process_block");
                             i -= 1;
                         }
                     },

benches/benches/benchmarks/resolve.rs

@@ -1,6 +1,6 @@
 use crate::benchmarks::util::create_2out_transaction;
 use ckb_app_config::{BlockAssemblerConfig, TxPoolConfig};
-use ckb_chain::chain::{ChainController, ChainService};
+use ckb_chain::{start_chain_services, ChainController};
 use ckb_chain_spec::{ChainSpec, IssuedCell};
 use ckb_jsonrpc_types::JsonBytes;
 use ckb_resource::Resource;
@@ -96,8 +96,7 @@ pub fn setup_chain(txs_size: usize) -> (Shared, ChainController) {
         .tx_pool_config(tx_pool_config)
         .build()
         .unwrap();
-    let chain_service = ChainService::new(shared.clone(), pack.take_proposal_table());
-    let chain_controller = chain_service.start(Some("ChainService"));
+    let chain_controller = start_chain_services(pack.take_chain_services_builder());
 
     // FIXME: global cache !!!
     let _ret = setup_system_cell_cache(