chore(blockifier): remove concurrency feature (#1262)

crates/blockifier/Cargo.toml

@@ -10,7 +10,6 @@ description = "The transaction-executing component in the Starknet sequencer."
 workspace = true
 
 [features]
-concurrency = []
 jemalloc = ["dep:tikv-jemallocator"]
 testing = ["rand", "rstest", "starknet_api/testing"]
 transaction_serde = []

crates/blockifier/src/blockifier/config.rs

@@ -4,8 +4,8 @@ pub struct TransactionExecutorConfig {
 }
 impl TransactionExecutorConfig {
     #[cfg(any(test, feature = "testing"))]
-    pub fn create_for_testing() -> Self {
-        Self { concurrency_config: ConcurrencyConfig::create_for_testing() }
+    pub fn create_for_testing(concurrency_enabled: bool) -> Self {
+        Self { concurrency_config: ConcurrencyConfig::create_for_testing(concurrency_enabled) }
     }
 }
 
@@ -15,16 +15,12 @@ pub struct ConcurrencyConfig {
     pub n_workers: usize,
     pub chunk_size: usize,
 }
-#[cfg(all(any(test, feature = "testing"), not(feature = "concurrency")))]
-impl ConcurrencyConfig {
-    pub fn create_for_testing() -> Self {
-        Self { enabled: false, n_workers: 0, chunk_size: 0 }
-    }
-}
 
-#[cfg(all(any(test, feature = "testing"), feature = "concurrency"))]
 impl ConcurrencyConfig {
-    pub fn create_for_testing() -> Self {
-        Self { enabled: true, n_workers: 4, chunk_size: 64 }
+    pub fn create_for_testing(concurrency_enabled: bool) -> Self {
+        if concurrency_enabled {
+            return Self { enabled: true, n_workers: 4, chunk_size: 64 };
+        }
+        Self { enabled: false, n_workers: 0, chunk_size: 0 }
     }
 }

crates/blockifier/src/blockifier/transaction_executor.rs

@@ -1,11 +1,6 @@
-#[cfg(feature = "concurrency")]
 use std::collections::{HashMap, HashSet};
-#[cfg(feature = "concurrency")]
 use std::panic::{self, catch_unwind, AssertUnwindSafe};
-#[cfg(feature = "concurrency")]
-use std::sync::Arc;
-#[cfg(feature = "concurrency")]
-use std::sync::Mutex;
+use std::sync::{Arc, Mutex};
 
 use itertools::FoldWhile::{Continue, Done};
 use itertools::Itertools;
@@ -15,7 +10,6 @@ use thiserror::Error;
 use crate::blockifier::block::{pre_process_block, BlockNumberHashPair};
 use crate::blockifier::config::TransactionExecutorConfig;
 use crate::bouncer::{Bouncer, BouncerWeights};
-#[cfg(feature = "concurrency")]
 use crate::concurrency::worker_logic::WorkerExecutor;
 use crate::context::BlockContext;
 use crate::state::cached_state::{CachedState, CommitmentStateDiff, TransactionalState};
@@ -144,14 +138,6 @@ impl<S: StateReader> TransactionExecutor<S> {
         results
     }
 
-    #[cfg(not(feature = "concurrency"))]
-    pub fn execute_chunk(
-        &mut self,
-        _chunk: &[Transaction],
-    ) -> Vec<TransactionExecutorResult<TransactionExecutionInfo>> {
-        unimplemented!()
-    }
-
     /// Returns the state diff, a list of contract class hash with the corresponding list of
     /// visited segment values and the block weights.
     pub fn finalize(
@@ -229,7 +215,6 @@ impl<S: StateReader + Send + Sync> TransactionExecutor<S> {
         }
     }
 
-    #[cfg(feature = "concurrency")]
     pub fn execute_chunk(
         &mut self,
         chunk: &[Transaction],

crates/blockifier/src/blockifier/transaction_executor_test.rs

@@ -280,8 +280,8 @@ fn test_bouncing(#[case] initial_bouncer_weights: BouncerWeights, #[case] n_even
 }
 
 #[rstest]
-fn test_execute_txs_bouncing() {
-    let config = TransactionExecutorConfig::create_for_testing();
+fn test_execute_txs_bouncing(#[values(true, false)] concurrency_enabled: bool) {
+    let config = TransactionExecutorConfig::create_for_testing(concurrency_enabled);
     let max_n_events_in_block = 10;
     let block_context = BlockContext::create_for_bouncer_testing(max_n_events_in_block);
 

crates/blockifier/src/blockifier/transfers_flow_test.rs

@@ -1,13 +1,19 @@
+use rstest::rstest;
+
+use crate::blockifier::config::ConcurrencyConfig;
 use crate::test_utils::transfers_generator::{
     RecipientGeneratorType,
     TransfersGenerator,
     TransfersGeneratorConfig,
 };
 
-#[test]
-pub fn transfers_flow_test() {
+#[rstest]
+#[case::concurrency_enabled(ConcurrencyConfig{enabled: true, n_workers: 4, chunk_size: 100})]
+#[case::concurrency_disabled(ConcurrencyConfig{enabled: false, n_workers: 0, chunk_size: 0})]
+pub fn transfers_flow_test(#[case] concurrency_config: ConcurrencyConfig) {
     let transfers_generator_config = TransfersGeneratorConfig {
         recipient_generator_type: RecipientGeneratorType::DisjointFromSenders,
+        concurrency_config,
         ..Default::default()
     };
     assert!(

crates/blockifier/src/lib.rs

@@ -12,7 +12,6 @@ static ALLOC: tikv_jemallocator::Jemalloc = tikv_jemallocator::Jemalloc;
 pub mod abi;
 pub mod blockifier;
 pub mod bouncer;
-#[cfg(feature = "concurrency")]
 pub mod concurrency;
 pub mod context;
 pub mod execution;

crates/blockifier/src/state/cached_state.rs

@@ -314,8 +314,7 @@ impl From<StorageView> for IndexMap<ContractAddress, IndexMap<StorageKey, Felt>>
     }
 }
 
-#[cfg_attr(any(feature = "testing", test), derive(Clone))]
-#[derive(Debug, Default, PartialEq, Eq)]
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
 pub struct StateMaps {
     pub nonces: HashMap<ContractAddress, Nonce>,
     pub class_hashes: HashMap<ContractAddress, ClassHash>,

crates/blockifier/src/test_utils/transfers_generator.rs

@@ -25,12 +25,6 @@ const RANDOMIZATION_SEED: u64 = 0;
 const CAIRO_VERSION: CairoVersion = CairoVersion::Cairo0;
 const TRANSACTION_VERSION: TransactionVersion = TransactionVersion(Felt::THREE);
 const RECIPIENT_GENERATOR_TYPE: RecipientGeneratorType = RecipientGeneratorType::RoundRobin;
-#[cfg(feature = "concurrency")]
-const CONCURRENCY_MODE: bool = true;
-#[cfg(not(feature = "concurrency"))]
-const CONCURRENCY_MODE: bool = false;
-const N_WORKERS: usize = 4;
-const CHUNK_SIZE: usize = 100;
 
 pub struct TransfersGeneratorConfig {
     pub n_accounts: u16,
@@ -55,11 +49,7 @@ impl Default for TransfersGeneratorConfig {
             cairo_version: CAIRO_VERSION,
             tx_version: TRANSACTION_VERSION,
             recipient_generator_type: RECIPIENT_GENERATOR_TYPE,
-            concurrency_config: ConcurrencyConfig {
-                enabled: CONCURRENCY_MODE,
-                n_workers: N_WORKERS,
-                chunk_size: CHUNK_SIZE,
-            },
+            concurrency_config: ConcurrencyConfig::default(),
         }
     }
 }

crates/native_blockifier/Cargo.toml

@@ -27,7 +27,7 @@ crate-type = ["cdylib"]
 
 [dependencies]
 # TODO(Dori, 1/1/2025): Add the "jemalloc" feature to the blockifier crate when possible.
-blockifier = { workspace = true, features = ["concurrency", "testing"] }
+blockifier = { workspace = true, features = ["testing"] }
 cairo-lang-starknet-classes.workspace = true
 cairo-vm.workspace = true
 indexmap.workspace = true

crates/native_blockifier/src/py_block_executor.rs

@@ -415,7 +415,7 @@ impl PyBlockExecutor {
         use blockifier::state::global_cache::GLOBAL_CONTRACT_CACHE_SIZE_FOR_TEST;
         Self {
             bouncer_config: BouncerConfig::max(),
-            tx_executor_config: TransactionExecutorConfig::create_for_testing(),
+            tx_executor_config: TransactionExecutorConfig::create_for_testing(true),
             storage: Box::new(storage),
             chain_info: ChainInfo::default(),
             versioned_constants: VersionedConstants::latest_constants().clone(),