memoizes the available parallelism call

- bump default concurrency const to 8 from 4
- memoize the result of the available parallelism call
- make `concurrency_limit` config property into `Option<usize>` instead
of `usize`

Author: dylanlott

src/config.rs

@@ -51,8 +51,9 @@ pub type HostProvider = FillProvider<
     RootProvider,
 >;
 
-/// The default concurrency limit for the builder if system call fails.
-pub const DEFAULT_CONCURRENCY_LIMIT: usize = 4;
+/// The default concurrency limit for the builder if the system call
+/// fails and no user-specified value is set.
+pub const DEFAULT_CONCURRENCY_LIMIT: usize = 8;
 
 /// Configuration for a builder running a specific rollup on a specific host
 /// chain.
@@ -153,10 +154,9 @@ pub struct BuilderConfig {
     /// The max number of simultaneous block simulations to run.
     #[from_env(
         var = "CONCURRENCY_LIMIT",
-        desc = "The max number of simultaneous block simulations to run",
-        optional
+        desc = "The max number of simultaneous block simulations to run"
     )]
-    pub concurrency_limit: usize,
+    pub concurrency_limit: Option<usize>,
 
     /// The slot calculator for the builder.
     pub slot_calculator: SlotCalculator,
@@ -281,13 +281,21 @@ impl BuilderConfig {
         SignetCfgEnv { chain_id: self.ru_chain_id }
     }
 
-    /// Get the concurrency limit for the current system.
+    /// Memoizes the concurrency limit for the current system. Uses [`std::thread::available_parallelism`] if no
+    /// value is set. If that for some reason fails, it returns the default concurrency limit.
     pub fn concurrency_limit(&self) -> usize {
-        if self.concurrency_limit == 0 {
+        static ONCE: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
+
+        if let Some(limit) = self.concurrency_limit {
+            if limit > 0 {
+                return limit;
+            }
+        }
+
+        *ONCE.get_or_init(|| {
             std::thread::available_parallelism()
                 .map(|p| p.get())
-                .unwrap_or(DEFAULT_CONCURRENCY_LIMIT);
-        }
-        self.concurrency_limit
+                .unwrap_or(DEFAULT_CONCURRENCY_LIMIT)
+        })
     }
 }

src/tasks/block/sim.rs

@@ -100,6 +100,7 @@ impl Simulator {
         block_env: BlockEnv,
     ) -> eyre::Result<BuiltBlock> {
         debug!(block_number = block_env.number, tx_count = sim_items.len(), "starting block build",);
+        let concurrency_limit = self.config.concurrency_limit();
 
         let db = self.create_db().await.unwrap();
 
@@ -109,7 +110,7 @@ impl Simulator {
             self.config.cfg_env(),
             block_env,
             finish_by,
-            self.config.concurrency_limit,
+            concurrency_limit,
             sim_items,
             self.config.rollup_block_gas_limit,
         );

src/test_utils.rs

@@ -40,7 +40,7 @@ pub fn setup_test_config() -> Result<BuilderConfig> {
             oauth_token_refresh_interval: 300, // 5 minutes
         },
         builder_helper_address: Address::default(),
-        concurrency_limit: 1000,
+        concurrency_limit: None, // NB: Defaults to available parallelism
         slot_calculator: SlotCalculator::new(
             1740681556, // pecorino start timestamp as sane default
             0, 1,