move shared_best_header from SyncState to Shared

eval-exec · eval-exec · commit 29961091d423 · 2025-09-17T13:01:36.000+08:00
Signed-off-by: Eval EXEC &lt;execvy@gmail.com&gt;
diff --git a/rpc/src/module/net.rs b/rpc/src/module/net.rs
@@ -731,7 +731,7 @@ impl NetRpc for NetRpcImpl {
         let shared = chain.shared();
         let state = chain.state();
         let (fast_time, normal_time, low_time) = state.read_inflight_blocks().division_point();
-        let best_known = state.shared_best_header();
+        let best_known = self.sync_shared.shared_best_header();
         let min_chain_work = {
             let mut min_chain_work_500k_u128: [u8; 16] = [0; 16];
             min_chain_work_500k_u128
@@ -751,7 +751,7 @@ impl NetRpc for NetRpcImpl {
             )
             .into(),
             min_chain_work: min_chain_work.into(),
-            min_chain_work_reached: state.min_chain_work_ready(),
+            min_chain_work_reached: self.sync_shared.min_chain_work_ready(),
             best_known_block_number: best_known.number().into(),
             best_known_block_timestamp: best_known.timestamp().into(),
             orphan_blocks_count: (self.chain_controller.orphan_blocks_len() as u64).into(),
diff --git a/shared/src/types/header_map/backend_sled.rs b/shared/src/types/header_map/backend_sled.rs
@@ -1,6 +1,8 @@
 #![allow(unused)]
 
+use crate::shared;
 use crate::types::HeaderIndexView;
+use ckb_logger::info;
 use ckb_types::{packed::Byte32, prelude::*};
 use sled::{Config, Db, Mode};
 use std::path;
@@ -9,6 +11,8 @@ use std::sync::atomic::AtomicUsize;
 use std::sync::atomic::Ordering;
 use tempfile::TempDir;
 
+const SHARED_BEST_HEADER_KEY: &[u8] = b"__ckb_shared_best_header__";
+
 pub(crate) struct SledBackend {
     count: AtomicUsize,
     db: Db,
@@ -33,6 +37,7 @@ impl SledBackend {
             });
         let header_map_path = header_map_base_path.join("header_map");
 
+        info!("header_map_path: {}", header_map_path.display());
         // use a smaller system page cache here since we are using sled as a temporary storage,
         // most of the time we will only read header from memory.
         let db: Db = Config::new()
@@ -42,14 +47,21 @@ impl SledBackend {
             .open()
             .expect("failed to open a key-value database to save header map into disk");
 
-        Self {
-            db,
-            _tmpdir,
-            count: AtomicUsize::new(0),
+        let count = AtomicUsize::new(db.len());
+        let header_map = Self { db, _tmpdir, count };
+        if let Some(shared_best_header) = header_map.load_shared_best_header() {
+            info!(
+                "found shared_best_header in SledBackend: {:?}",
+                shared_best_header.number_and_hash()
+            );
+            header_map.count.fetch_sub(1, Ordering::SeqCst);
         }
+        info!("SledBackend have {} items", header_map.len());
+
+        header_map
     }
 
-    fn len(&self) -> usize {
+    pub fn len(&self) -> usize {
         self.count.load(Ordering::SeqCst)
     }
 
@@ -118,4 +130,33 @@ impl SledBackend {
             self.count.fetch_sub(1, Ordering::SeqCst);
         }
     }
+
+    pub fn load_shared_best_header(&self) -> Option<HeaderIndexView> {
+        self.db
+            .get(SHARED_BEST_HEADER_KEY)
+            .unwrap_or_else(|err| {
+                panic!("read shared best header from disk should be ok, but {err}")
+            })
+            .map(|slice| {
+                if slice.len() < 32 {
+                    panic!(
+                        "stored shared best header should contain hash and payload, len {}",
+                        slice.len()
+                    );
+                }
+                let (hash, payload) = slice.split_at(32);
+                HeaderIndexView::from_slice_should_be_ok(hash, payload)
+            })
+    }
+
+    pub fn store_shared_best_header(&self, header: &HeaderIndexView) {
+        let hash = header.hash();
+        let payload = header.to_vec();
+        let mut buf = Vec::with_capacity(32 + payload.len());
+        buf.extend_from_slice(hash.as_slice());
+        buf.extend_from_slice(&payload);
+        self.db
+            .insert(SHARED_BEST_HEADER_KEY, buf)
+            .expect("failed to persist shared best header to sled");
+    }
 }
diff --git a/shared/src/types/header_map/kernel_lru.rs b/shared/src/types/header_map/kernel_lru.rs
@@ -2,14 +2,13 @@ use std::path;
 use std::sync::Arc;
 use std::sync::atomic::{AtomicBool, Ordering};
 
-use ckb_logger::info;
-#[cfg(feature = "stats")]
 use ckb_logger::info;
 use ckb_metrics::HistogramTimer;
 #[cfg(feature = "stats")]
 use ckb_util::{Mutex, MutexGuard};
+use ckb_util::{RwLock, RwLockReadGuard};
 
-use ckb_types::packed::Byte32;
+use ckb_types::{U256, core::EpochNumberWithFraction, packed::Byte32};
 
 use super::{MemoryMap, SledBackend};
 use crate::types::HeaderIndexView;
@@ -21,6 +20,7 @@ pub(crate) struct HeaderMapKernel {
     memory_limit: usize,
     // if ckb is in IBD mode, don't shrink memory map
     ibd_finished: Arc<AtomicBool>,
+    shared_best_header: RwLock<HeaderIndexView>,
     // Statistics
     #[cfg(feature = "stats")]
     stats: Mutex<HeaderMapKernelStats>,
@@ -54,6 +54,8 @@ impl Drop for HeaderMapKernel {
             self.memory
                 .remove_batch(items.iter().map(|item| item.hash()), false);
         }
+        let best_header = self.shared_best_header.read().clone();
+        self.backend.store_shared_best_header(&best_header);
         info!("HeaderMap persisted all items to backend");
     }
 }
@@ -69,6 +71,11 @@ impl HeaderMapKernel {
     {
         let memory = Default::default();
         let backend = SledBackend::new(tmpdir);
+        info!("backend is empty: {}", backend.is_empty());
+        let shared_best_header_value = backend
+            .load_shared_best_header()
+            .unwrap_or_else(Self::default_shared_best_header);
+        let shared_best_header = RwLock::new(shared_best_header_value);
 
         #[cfg(not(feature = "stats"))]
         {
@@ -77,6 +84,7 @@ impl HeaderMapKernel {
                 backend,
                 memory_limit,
                 ibd_finished,
+                shared_best_header,
             }
         }
 
@@ -87,6 +95,7 @@ impl HeaderMapKernel {
                 backend,
                 memory_limit,
                 ibd_finished,
+                shared_best_header,
                 stats: Mutex::new(HeaderMapKernelStats::new(50_000)),
             }
         }
@@ -192,6 +201,43 @@ impl HeaderMapKernel {
         }
     }
 
+    pub(crate) fn shared_best_header(&self) -> HeaderIndexView {
+        self.shared_best_header.read().clone()
+    }
+
+    pub(crate) fn shared_best_header_ref(&self) -> RwLockReadGuard<HeaderIndexView> {
+        self.shared_best_header.read()
+    }
+
+    pub(crate) fn set_shared_best_header(&self, header: HeaderIndexView) {
+        if let Some(metrics) = ckb_metrics::handle() {
+            metrics.ckb_shared_best_number.set(header.number() as i64);
+        }
+        *self.shared_best_header.write() = header;
+    }
+
+    pub(crate) fn may_set_shared_best_header(&self, header: HeaderIndexView) {
+        {
+            let current = self.shared_best_header.read();
+            if !header.is_better_than(current.total_difficulty()) {
+                return;
+            }
+        }
+
+        self.set_shared_best_header(header);
+    }
+
+    fn default_shared_best_header() -> HeaderIndexView {
+        HeaderIndexView::new(
+            Byte32::zero(),
+            0,
+            EpochNumberWithFraction::from_full_value(0),
+            0,
+            Byte32::default(),
+            U256::zero(),
+        )
+    }
+
     #[cfg(feature = "stats")]
     fn trace(&self) {
         let mut stats = self.stats();
diff --git a/shared/src/types/header_map/mod.rs b/shared/src/types/header_map/mod.rs
@@ -8,6 +8,7 @@ use std::time::Duration;
 use std::{mem::size_of, path};
 
 use ckb_metrics::HistogramTimer;
+use ckb_util::RwLockReadGuard;
 use tokio::time::MissedTickBehavior;
 
 mod backend_sled;
@@ -111,4 +112,20 @@ impl HeaderMap {
 
         self.inner.remove(hash)
     }
+
+    pub fn shared_best_header(&self) -> HeaderIndexView {
+        self.inner.shared_best_header()
+    }
+
+    pub fn shared_best_header_ref(&self) -> RwLockReadGuard<HeaderIndexView> {
+        self.inner.shared_best_header_ref()
+    }
+
+    pub fn set_shared_best_header(&self, header: HeaderIndexView) {
+        self.inner.set_shared_best_header(header)
+    }
+
+    pub fn may_set_shared_best_header(&self, header: HeaderIndexView) {
+        self.inner.may_set_shared_best_header(header)
+    }
 }
diff --git a/sync/src/synchronizer/headers_process.rs b/sync/src/synchronizer/headers_process.rs
@@ -62,7 +62,7 @@ impl<'a> HeadersProcess<'a> {
     fn debug(&self) {
         if log_enabled!(Level::Debug) {
             // Regain the updated best known
-            let shared_best_known = self.synchronizer.shared.state().shared_best_header();
+            let shared_best_known = self.synchronizer.shared.shared_best_header();
             let peer_best_known = self.synchronizer.peers().get_best_known_header(self.peer);
             debug!(
                 "chain: num={}, diff={:#x};",
diff --git a/sync/src/synchronizer/mod.rs b/sync/src/synchronizer/mod.rs
@@ -120,7 +120,7 @@ impl BlockFetchCMD {
             CanStart::FetchToTarget(assume_target) => fetch_blocks_fn(self, assume_target),
             CanStart::Ready => fetch_blocks_fn(self, BlockNumber::MAX),
             CanStart::MinWorkNotReach => {
-                let best_known = self.sync_shared.state().shared_best_header_ref();
+                let best_known = self.sync_shared.shared_best_header_ref();
                 let number = best_known.number();
                 if number != self.number && (number - self.number) % 10000 == 0 {
                     self.number = number;
@@ -134,9 +134,8 @@ impl BlockFetchCMD {
                 }
             }
             CanStart::AssumeValidNotFound => {
-                let state = self.sync_shared.state();
                 let shared = self.sync_shared.shared();
-                let best_known = state.shared_best_header_ref();
+                let best_known = self.sync_shared.shared_best_header_ref();
                 let number = best_known.number();
                 let assume_valid_target: Byte32 = shared
                     .assume_valid_targets()
@@ -192,7 +191,7 @@ impl BlockFetchCMD {
             .genesis_block()
             .header()
             .timestamp();
-        let shared_best_timestamp = self.sync_shared.state().shared_best_header().timestamp();
+        let shared_best_timestamp = self.sync_shared.shared_best_header().timestamp();
 
         let ckb_process_start_timestamp = self.start_timestamp;
 
@@ -236,10 +235,9 @@ impl BlockFetchCMD {
         }
 
         let shared = self.sync_shared.shared();
-        let state = self.sync_shared.state();
 
         let min_work_reach = |flag: &mut CanStart| {
-            if state.min_chain_work_ready() {
+            if self.sync_shared.min_chain_work_ready() {
                 *flag = CanStart::AssumeValidNotFound;
             }
         };
@@ -278,7 +276,7 @@ impl BlockFetchCMD {
                     None => {
                         // Best known already not in the scope of ibd, it means target is invalid
                         if unix_time_as_millis()
-                            .saturating_sub(state.shared_best_header_ref().timestamp())
+                            .saturating_sub(self.sync_shared.shared_best_header_ref().timestamp())
                             < MAX_TIP_AGE
                         {
                             warn!(
@@ -428,7 +426,7 @@ impl Synchronizer {
                 active_chain.total_difficulty().to_owned(),
             )
         };
-        let best_known = self.shared.state().shared_best_header();
+        let best_known = self.shared.shared_best_header();
         // is_better_chain
         if total_difficulty > *best_known.total_difficulty() {
             (header, total_difficulty).into()
@@ -782,7 +780,7 @@ impl Synchronizer {
                         .unwrap();
                     self.fetch_channel = Some(sender);
                     let thread = ::std::thread::Builder::new();
-                    let number = self.shared.state().shared_best_header_ref().number();
+                    let number = self.shared.shared_best_header_ref().number();
                     const THREAD_NAME: &str = "BlockDownload";
                     let sync_shared: Arc<SyncShared> = Arc::to_owned(self.shared());
                     let blockdownload_jh = thread
diff --git a/sync/src/types/mod.rs b/sync/src/types/mod.rs
