[Optimize] Cache the recently queried committees

node/bft/ledger-service/Cargo.toml

@@ -20,7 +20,7 @@ edition = "2021"
 default = [ ]
 ledger = [ "rand", "tokio", "tracing" ]
 ledger-write = [ ]
-mock = [ "parking_lot", "tracing" ]
+mock = [ "tracing" ]
 prover = [ ]
 test = [ "mock", "translucent" ]
 translucent = [ "ledger" ]
@@ -32,9 +32,11 @@ version = "0.1"
 version = "2.1"
 features = [ "serde", "rayon" ]
 
+[dependencies.lru]
+version = "0.12"
+
 [dependencies.parking_lot]
 version = "0.12"
-optional = true
 
 [dependencies.rand]
 version = "0.8"

node/bft/ledger-service/src/ledger.rs

@@ -26,6 +26,8 @@ use snarkvm::{
 };
 
 use indexmap::IndexMap;
+use lru::LruCache;
+use parking_lot::Mutex;
 use std::{
     fmt,
     ops::Range,
@@ -35,18 +37,23 @@ use std::{
     },
 };
 
+/// The capacity of the LRU holiding the recently queried committees.
+const COMMITTEE_CACHE_SIZE: usize = 16;
+
 /// A core ledger service.
 pub struct CoreLedgerService<N: Network, C: ConsensusStorage<N>> {
     ledger: Ledger<N, C>,
     coinbase_verifying_key: Arc<CoinbaseVerifyingKey<N>>,
     shutdown: Arc<AtomicBool>,
+    committee_cache: Arc<Mutex<LruCache<u64, Committee<N>>>>,
 }
 
 impl<N: Network, C: ConsensusStorage<N>> CoreLedgerService<N, C> {
     /// Initializes a new core ledger service.
     pub fn new(ledger: Ledger<N, C>, shutdown: Arc<AtomicBool>) -> Self {
         let coinbase_verifying_key = Arc::new(ledger.coinbase_puzzle().coinbase_verifying_key().clone());
-        Self { ledger, coinbase_verifying_key, shutdown }
+        let committee_cache = Arc::new(Mutex::new(LruCache::new(COMMITTEE_CACHE_SIZE.try_into().unwrap())));
+        Self { ledger, coinbase_verifying_key, shutdown, committee_cache }
     }
 }
 
@@ -127,20 +134,30 @@ impl<N: Network, C: ConsensusStorage<N>> LedgerService<N> for CoreLedgerService<
     /// Returns the committee for the given round.
     /// If the given round is in the future, then the current committee is returned.
     fn get_committee_for_round(&self, round: u64) -> Result<Committee<N>> {
-        match self.ledger.get_committee_for_round(round)? {
+        // Check if the committee is already in the cache.
+        if let Some(committee) = self.committee_cache.lock().get(&round) {
+            return Ok(committee.clone());
+        }
+
+        let committee = match self.ledger.get_committee_for_round(round)? {
             // Return the committee if it exists.
-            Some(committee) => Ok(committee),
+            Some(committee) => committee,
             // Return the current committee if the round is in the future.
             None => {
                 // Retrieve the current committee.
                 let current_committee = self.current_committee()?;
                 // Return the current committee if the round is in the future.
                 match current_committee.starting_round() <= round {
-                    true => Ok(current_committee),
+                    true => current_committee,
                     false => bail!("No committee found for round {round} in the ledger"),
                 }
             }
-        }
+        };
+
+        // Insert the committee into the cache.
+        self.committee_cache.lock().push(round, committee.clone());
+
+        Ok(committee)
     }
 
     /// Returns the committee lookback for the given round.