a290a3c537
## Issue Addressed Successor to #2431 ## Proposed Changes * Add a `BlockReplayer` struct to abstract over the intricacies of calling `per_slot_processing` and `per_block_processing` while avoiding unnecessary tree hashing. * Add a variant of the forwards state root iterator that does not require an `end_state`. * Use the `BlockReplayer` when reconstructing states in the database. Use the efficient forwards iterator for frozen states. * Refactor the iterators to remove `Arc<HotColdDB>` (this seems to be neater than making _everything_ an `Arc<HotColdDB>` as I did in #2431). Supplying the state roots allow us to avoid building a tree hash cache at all when reconstructing historic states, which saves around 1 second flat (regardless of `slots-per-restore-point`). This is a small percentage of worst-case state load times with 200K validators and SPRP=2048 (~15s vs ~16s) but a significant speed-up for more frequent restore points: state loads with SPRP=32 should be now consistently <500ms instead of 1.5s (a ~3x speedup). ## Additional Info Required by https://github.com/sigp/lighthouse/pull/2628
112 lines
2.8 KiB
Rust
112 lines
2.8 KiB
Rust
use crate::chunked_vector::ChunkError;
|
|
use crate::config::StoreConfigError;
|
|
use crate::hot_cold_store::HotColdDBError;
|
|
use ssz::DecodeError;
|
|
use state_processing::BlockReplayError;
|
|
use types::{BeaconStateError, Hash256, Slot};
|
|
|
|
pub type Result<T> = std::result::Result<T, Error>;
|
|
|
|
#[derive(Debug)]
|
|
pub enum Error {
|
|
SszDecodeError(DecodeError),
|
|
VectorChunkError(ChunkError),
|
|
BeaconStateError(BeaconStateError),
|
|
PartialBeaconStateError,
|
|
HotColdDBError(HotColdDBError),
|
|
DBError {
|
|
message: String,
|
|
},
|
|
RlpError(String),
|
|
BlockNotFound(Hash256),
|
|
NoContinuationData,
|
|
SplitPointModified(Slot, Slot),
|
|
ConfigError(StoreConfigError),
|
|
SchemaMigrationError(String),
|
|
/// The store's `anchor_info` was mutated concurrently, the latest modification wasn't applied.
|
|
AnchorInfoConcurrentMutation,
|
|
/// The block or state is unavailable due to weak subjectivity sync.
|
|
HistoryUnavailable,
|
|
/// State reconstruction cannot commence because not all historic blocks are known.
|
|
MissingHistoricBlocks {
|
|
oldest_block_slot: Slot,
|
|
},
|
|
/// State reconstruction failed because it didn't reach the upper limit slot.
|
|
///
|
|
/// This should never happen (it's a logic error).
|
|
StateReconstructionDidNotComplete,
|
|
StateReconstructionRootMismatch {
|
|
slot: Slot,
|
|
expected: Hash256,
|
|
computed: Hash256,
|
|
},
|
|
BlockReplayError(BlockReplayError),
|
|
}
|
|
|
|
pub trait HandleUnavailable<T> {
|
|
fn handle_unavailable(self) -> std::result::Result<Option<T>, Error>;
|
|
}
|
|
|
|
impl<T> HandleUnavailable<T> for Result<T> {
|
|
fn handle_unavailable(self) -> std::result::Result<Option<T>, Error> {
|
|
match self {
|
|
Ok(x) => Ok(Some(x)),
|
|
Err(Error::HistoryUnavailable) => Ok(None),
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<DecodeError> for Error {
|
|
fn from(e: DecodeError) -> Error {
|
|
Error::SszDecodeError(e)
|
|
}
|
|
}
|
|
|
|
impl From<ChunkError> for Error {
|
|
fn from(e: ChunkError) -> Error {
|
|
Error::VectorChunkError(e)
|
|
}
|
|
}
|
|
|
|
impl From<HotColdDBError> for Error {
|
|
fn from(e: HotColdDBError) -> Error {
|
|
Error::HotColdDBError(e)
|
|
}
|
|
}
|
|
|
|
impl From<BeaconStateError> for Error {
|
|
fn from(e: BeaconStateError) -> Error {
|
|
Error::BeaconStateError(e)
|
|
}
|
|
}
|
|
|
|
impl From<DBError> for Error {
|
|
fn from(e: DBError) -> Error {
|
|
Error::DBError { message: e.message }
|
|
}
|
|
}
|
|
|
|
impl From<StoreConfigError> for Error {
|
|
fn from(e: StoreConfigError) -> Error {
|
|
Error::ConfigError(e)
|
|
}
|
|
}
|
|
|
|
impl From<BlockReplayError> for Error {
|
|
fn from(e: BlockReplayError) -> Error {
|
|
Error::BlockReplayError(e)
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct DBError {
|
|
pub message: String,
|
|
}
|
|
|
|
impl DBError {
|
|
pub fn new(message: String) -> Self {
|
|
Self { message }
|
|
}
|
|
}
|