feat: calculate state root in background

[keefel]

Description

This PR adds an option to calculate the state root in the background, improving block insertion performance during live sync.

Rationale

Calculating the state root during live sync takes a lot of time, resulting in poor performance. This feature allows for background calculation of the state root and merges calculations for multiple blocks to update the trie simultaneously. Our tests show that enabling this feature can improve performance from 50 mgasps to 400 mgasps.

Without this feature:

With this feature enabled:

Example

NA

Changes

Notable changes:

• Calculate the state root in the background.
• Merge the calculation of the state root for multiple blocks.

Potential Impacts

• The persistent database should align with the background calculation of the state root.
• When unwinding blocks, you can only unwind to the block where the state root has been calculated.

[unclezoro]

seems too many duplicated code

[unclezoro]

and I did see the different between new added code and the previous one

[j75689]

you can define the oneshot::Receiver in an enum to make the code more structured and readable:

pub(crate) enum PersistenceReceiver {
    /// Receiver for simple persistence tasks.
    Simple(oneshot::Receiver<Option<BlockNumHash>>),
    /// Receiver for persistence tasks with root updates.
    WithRootUpdates(oneshot::Receiver<(Option<BlockNumHash>, TrieUpdates)>),
}

pub struct PersistenceState {
    /// Hash and number of the last block persisted.
    ///
    /// This tracks the chain height that is persisted on disk
    pub(crate) last_persisted_block: BlockNumHash,
    /// Receiver end of channel where the result of the persistence task will be
    /// sent when done. A None value means there's no persistence task in progress.
    pub(crate) rx: Option<(PersistenceReceiver, Instant)>,
    /// The block above which blocks should be removed from disk, because there has been an on disk
    /// reorg.
    pub(crate) remove_above_state: VecDeque<u64>,
}

And use a match statement to handle different types of responses, improving readability and maintainability:

if self.persistence_state.in_progress() {
    let (rx, start_time) = self
        .persistence_state
        .rx
        .take()
        .expect("If a persistence task is in progress, Receiver must be Some");

    match rx {
        PersistenceReceiver::Simple(mut rx) => {
            // Check if the persistence task has completed
            match rx.try_recv() {
                Ok(last_persisted_hash_num) => {
                    // Handle the result of the simple persistence task
                }
                Err(_) => {
                    // Handle errors or pending state
                }
            }
        }
        PersistenceReceiver::WithRootUpdates(mut rx) => {
            // Check if the persistence task with root updates has completed
            match rx.try_recv() {
                Ok(persistence_result) => {
                    // Handle the result of the persistence task with root updates
                }
                Err(_) => {
                    // Handle errors or pending state
                }
            }
        }
    }
}

[keefel]

fixed