Struct cfxcore::sync::SynchronizationGraph

pub struct SynchronizationGraph {
    pub inner: Arc<RwLock<SynchronizationGraphInner>>,
    pub consensus: SharedConsensusGraph,
    pub data_man: Arc<BlockDataManager>,
    pub pow: Arc<PowComputer>,
    pub verification_config: VerificationConfig,
    pub sync_config: SyncGraphConfig,
    pub statistics: SharedStatistics,
    pub future_blocks: FutureBlockContainer,
    /* private fields */
}

Fields

inner: Arc<RwLock<SynchronizationGraphInner>>

consensus: SharedConsensusGraph

data_man: Arc<BlockDataManager>

pow: Arc<PowComputer>

verification_config: VerificationConfig

sync_config: SyncGraphConfig

statistics: SharedStatistics

future_blocks: FutureBlockContainer

The blocks whose timestamps are near future. They will be inserted into sync graph inner at their timestamp.

Implementations

impl SynchronizationGraph

pub fn new( consensus: SharedConsensusGraph, verification_config: VerificationConfig, pow_config: ProofOfWorkConfig, pow: Arc<PowComputer>, sync_config: SyncGraphConfig, notifications: Arc<Notifications>, machine: Arc<Machine>, pos_verifier: Arc<PosVerifier> ) -> Self

pub fn is_consortium(&self) -> bool

pub fn machine(&self) -> Arc<Machine>

pub fn get_genesis_hash_and_height_in_current_era(&self) -> (H256, u64)

pub fn expected_difficulty(&self, parent_hash: &H256) -> U256

Compute the expected difficulty for a block given its parent hash

pub fn get_to_propagate_trans(&self) -> HashMap<H256, Arc<SignedTransaction>>

pub fn set_to_propagate_trans( &self, transactions: HashMap<H256, Arc<SignedTransaction>> )

pub fn recover_graph_from_db(&self)

In full/archive node, this function can be invoked during CatchUpRecoverBlockHeaderFromDbPhase phase. It tries to construct the consensus graph based on header information stored in db.

pub fn block_header_by_hash(&self, hash: &H256) -> Option<BlockHeader>

Return None if hash is not in sync graph

pub fn block_height_by_hash(&self, hash: &H256) -> Option<u64>

Return None if hash is not in sync graph

pub fn block_timestamp_by_hash(&self, hash: &H256) -> Option<u64>

Return None if hash is not in sync graph

pub fn block_by_hash(&self, hash: &H256) -> Option<Arc<Block>>

TODO Be more specific about which functions only return in-memory data and which can return the in-database data

pub fn contains_block_header(&self, hash: &H256) -> bool

pub fn insert_block_header( &self, header: &mut BlockHeader, need_to_verify: bool, bench_mode: bool, insert_to_consensus: bool, persistent: bool ) -> (BlockHeaderInsertionResult, Vec<H256>)

pub fn contains_block(&self, hash: &H256) -> bool

pub fn insert_block( &self, block: Block, need_to_verify: bool, persistent: bool, recover_from_db: bool ) -> BlockInsertionResult

pub fn get_all_block_hashes_by_epoch( &self, epoch_number: u64 ) -> Result<Vec<H256>, String>

pub fn log_statistics(&self)

pub fn update_total_weight_delta_heartbeat(&self)

pub fn block_count(&self) -> usize

Get the current number of blocks in the synchronization graph This only returns cached block count, and this is enough since this is only used in test.

pub fn remove_expire_blocks(&self, expire_time: u64)

Remove all blocks which have not been updated for a long time. We maintain a set not_ready_blocks_frontier which is the root nodes in the parental tree formed by not graph ready blocks. Find all expire blocks which can be reached by not_ready_blocks_frontier.

pub fn remove_blocks_and_future(&self, to_remove_set: &HashSet<H256>)

Remove all blocks in to_remove_set and their future set from the graph.

pub fn is_consensus_worker_busy(&self) -> bool

pub fn is_fill_block_completed(&self) -> bool

pub fn complete_filling_block_bodies(&self) -> bool

Construct the states along the pivot chain, set all BLOCK_HEADER_GRAPH_READY blocks as BLOCK_GRAPH_READY and remove all other blocks. All blocks in the future can be processed normally in sync graph and consensus graph.

If some blocks become invalid after validating their bodies, we need to remove them and reconstruct the consensus graph. Return false if there are blocks in the new consensus graph whose bodies are missing. Return true if we do not need to reconstruct consensus, or all blocks in the new consensus graph already have bodies.

pub fn check_not_ready_frontier(&self, header_only: bool)

TODO(lpl): Only triggered when pos commits new blocks? Check if not_ready_frontier blocks become ready now. Blocks that are not ready because of missing pos references only become ready here.

Trait Implementations

impl MallocSizeOf for SynchronizationGraph

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.