Struct WritebackCache

pub struct WritebackCache { /* private fields */ }

Implementations

impl WritebackCache

pub fn new( config: &ExecutionCacheConfig, store: Arc<AuthorityStore>, metrics: Arc<ExecutionCacheMetrics>, backpressure_manager: Arc<BackpressureManager>, ) -> Self

pub fn new_for_tests(store: Arc<AuthorityStore>, registry: &Registry) -> Self

pub fn clear_caches_and_assert_empty(&self)

Trait Implementations

impl AccumulatorStore for WritebackCache

fn get_object_ref_prior_to_key_deprecated( &self, object_id: &ObjectID, version: SequenceNumber, ) -> SuiResult<Option<ObjectRef>>

This function is only called in older protocol versions, and should no longer be used. It creates an explicit dependency to tombstones which is not desired.

fn get_root_state_accumulator_for_epoch( &self, epoch: EpochId, ) -> SuiResult<Option<(CheckpointSequenceNumber, Accumulator)>>

fn get_root_state_accumulator_for_highest_epoch( &self, ) -> SuiResult<Option<(EpochId, (CheckpointSequenceNumber, Accumulator))>>

fn insert_state_accumulator_for_epoch( &self, epoch: EpochId, checkpoint_seq_num: &CheckpointSequenceNumber, acc: &Accumulator, ) -> SuiResult

fn iter_live_object_set( &self, include_wrapped_tombstone: bool, ) -> Box<dyn Iterator<Item = LiveObject> + '_>

fn iter_cached_live_object_set_for_testing( &self, include_wrapped_tombstone: bool, ) -> Box<dyn Iterator<Item = LiveObject> + '_>

impl BackingPackageStore for WritebackCache

fn get_package_object( &self, package_id: &ObjectID, ) -> SuiResult<Option<PackageObject>>

impl CheckpointCache for WritebackCache

fn deprecated_get_transaction_checkpoint( &self, digest: &TransactionDigest, ) -> Option<(EpochId, CheckpointSequenceNumber)>

fn deprecated_multi_get_transaction_checkpoint( &self, digests: &[TransactionDigest], ) -> Vec<Option<(EpochId, CheckpointSequenceNumber)>>

fn deprecated_insert_finalized_transactions( &self, digests: &[TransactionDigest], epoch: EpochId, sequence: CheckpointSequenceNumber, )

impl ChildObjectResolver for WritebackCache

fn read_child_object( &self, parent: &ObjectID, child: &ObjectID, child_version_upper_bound: SequenceNumber, ) -> SuiResult<Option<Object>>

child must have an ObjectOwner ownership equal to owner.

fn get_object_received_at_version( &self, owner: &ObjectID, receiving_object_id: &ObjectID, receive_object_at_version: SequenceNumber, epoch_id: EpochId, ) -> SuiResult<Option<Object>>

receiving_object_id must have an AddressOwner ownership equal to owner. get_object_received_at_version must be the exact version at which the object will be received, and it cannot have been previously received at that version. NB: An object not existing at that version, and not having valid access to the object will be treated exactly the same and Ok(None) must be returned.

impl ExecutionCacheCommit for WritebackCache

fn build_db_batch(&self, epoch: EpochId, digests: &[TransactionDigest]) -> Batch

Build a DBBatch containing the given transaction outputs.

fn commit_transaction_outputs( &self, epoch: EpochId, batch: Batch, digests: &[TransactionDigest], )

Durably commit the outputs of the given transactions to the database. Will be called by CheckpointExecutor to ensure that transaction outputs are written durably before marking a checkpoint as finalized.

fn persist_transaction(&self, tx: &VerifiedExecutableTransaction)

Durably commit a transaction to the database. Used to store any transactions that cannot be reconstructed at start-up by consensus replay. Currently the only case of this is RandomnessStateUpdate.

fn approximate_pending_transaction_count(&self) -> u64

impl ExecutionCacheReconfigAPI for WritebackCache

fn insert_genesis_object(&self, object: Object)

fn bulk_insert_genesis_objects(&self, objects: &[Object])

fn revert_state_update(&self, digest: &TransactionDigest)

fn set_epoch_start_configuration( &self, epoch_start_config: &EpochStartConfiguration, )

fn update_epoch_flags_metrics(&self, old: &[EpochFlag], new: &[EpochFlag])

fn clear_state_end_of_epoch( &self, execution_guard: &RwLockWriteGuard<'_, EpochId>, )

fn expensive_check_sui_conservation( &self, old_epoch_store: &AuthorityPerEpochStore, ) -> SuiResult

fn checkpoint_db(&self, path: &Path) -> SuiResult

fn maybe_reaccumulate_state_hash( &self, cur_epoch_store: &AuthorityPerEpochStore, new_protocol_version: ProtocolVersion, )

This is a temporary method to be used when we enable simplified_unwrap_then_delete. It re-accumulates state hash for the new epoch if simplified_unwrap_then_delete is enabled.

fn reconfigure_cache<'a>( &'a self, _: &'a EpochStartConfiguration, ) -> BoxFuture<'a, ()>

Reconfigure the cache itself. TODO: this is only needed for ProxyCache to switch between cache impls. It can be removed once WritebackCache is the sole cache impl.

impl ExecutionCacheWrite for WritebackCache

fn acquire_transaction_locks( &self, epoch_store: &AuthorityPerEpochStore, owned_input_objects: &[ObjectRef], tx_digest: TransactionDigest, signed_transaction: Option<VerifiedSignedTransaction>, ) -> SuiResult

Attempt to acquire object locks for all of the owned input locks.

fn write_transaction_outputs( &self, epoch_id: EpochId, tx_outputs: Arc<TransactionOutputs>, )

Write the output of a transaction.

impl ObjectCacheRead for WritebackCache

fn get_package_object( &self, package_id: &ObjectID, ) -> SuiResult<Option<PackageObject>>

fn force_reload_system_packages(&self, _system_package_ids: &[ObjectID])

fn get_object(&self, id: &ObjectID) -> Option<Object>

fn get_object_by_key( &self, object_id: &ObjectID, version: SequenceNumber, ) -> Option<Object>

fn multi_get_objects_by_key( &self, object_keys: &[ObjectKey], ) -> Vec<Option<Object>>

fn object_exists_by_key( &self, object_id: &ObjectID, version: SequenceNumber, ) -> bool

fn multi_object_exists_by_key(&self, object_keys: &[ObjectKey]) -> Vec<bool>

fn get_latest_object_ref_or_tombstone( &self, object_id: ObjectID, ) -> Option<ObjectRef>

fn get_latest_object_or_tombstone( &self, object_id: ObjectID, ) -> Option<(ObjectKey, ObjectOrTombstone)>

fn find_object_lt_or_eq_version( &self, object_id: ObjectID, version_bound: SequenceNumber, ) -> Option<Object>

Return the object with version less then or eq to the provided seq number. This is used by indexer to find the correct version of dynamic field child object. We do not store the version of the child object, but because of lamport timestamp, we know the child must have version number less then or eq to the parent.

fn get_sui_system_state_object_unsafe(&self) -> SuiResult<SuiSystemState>

fn get_bridge_object_unsafe(&self) -> SuiResult<Bridge>

fn get_marker_value( &self, object_key: FullObjectKey, epoch_id: EpochId, ) -> Option<MarkerValue>

Get the marker at a specific version

fn get_latest_marker( &self, object_id: FullObjectID, epoch_id: EpochId, ) -> Option<(SequenceNumber, MarkerValue)>

Get the latest marker for a given object.

fn get_lock( &self, obj_ref: ObjectRef, epoch_store: &AuthorityPerEpochStore, ) -> SuiResult<ObjectLockStatus>

fn _get_live_objref(&self, object_id: ObjectID) -> SuiResult<ObjectRef>

fn check_owned_objects_are_live( &self, owned_object_refs: &[ObjectRef], ) -> SuiResult

fn get_highest_pruned_checkpoint(&self) -> Option<CheckpointSequenceNumber>

Return the watermark for the highest checkpoint for which we’ve pruned objects.

fn get_objects(&self, objects: &[ObjectID]) -> Vec<Option<Object>>

fn multi_get_objects_with_more_accurate_error_return( &self, object_refs: &[ObjectRef], ) -> Result<Vec<Object>, SuiError>

Load a list of objects from the store by object reference. If they exist in the store, they are returned directly. If any object missing, we try to figure out the best error to return. If the object we are asking is currently locked at a future version, we know this transaction is out-of-date and we return a ObjectVersionUnavailableForConsumption, which indicates this is not retriable. Otherwise, we return a ObjectNotFound error, which indicates this is retriable.

fn multi_input_objects_available( &self, keys: &[InputKey], receiving_objects: HashSet<InputKey>, epoch: EpochId, ) -> Vec<bool>

Used by transaction manager to determine if input objects are ready. Distinct from multi_get_object_by_key because it also consults markers to handle the case where an object will never become available (e.g. because it has been received by some other transaction already).

fn get_last_consensus_stream_end_info( &self, object_id: FullObjectID, epoch_id: EpochId, ) -> Option<(SequenceNumber, TransactionDigest)>

If the given consensus object stream was ended, return related version and transaction digest.

fn get_consensus_stream_end_tx_digest( &self, object_key: FullObjectKey, epoch_id: EpochId, ) -> Option<TransactionDigest>

If the given consensus object stream was ended at the specified version, return related transaction digest.

fn have_received_object_at_version( &self, object_key: FullObjectKey, epoch_id: EpochId, ) -> bool

fn fastpath_stream_ended_at_version_or_after( &self, object_id: ObjectID, version: SequenceNumber, epoch_id: EpochId, ) -> bool

impl ObjectStore for WritebackCache

fn get_object(&self, object_id: &ObjectID) -> Option<Object>

fn get_object_by_key( &self, object_id: &ObjectID, version: VersionNumber, ) -> Option<Object>

fn multi_get_objects(&self, object_ids: &[ObjectID]) -> Vec<Option<Object>>

fn multi_get_objects_by_key( &self, object_keys: &[ObjectKey], ) -> Vec<Option<Object>>

impl ParentSync for WritebackCache

fn get_latest_parent_entry_ref_deprecated( &self, object_id: ObjectID, ) -> Option<ObjectRef>

This function is only called by older protocol versions. It creates an explicit dependency to tombstones, which is not desired.

impl StateSyncAPI for WritebackCache

fn insert_transaction_and_effects( &self, transaction: &VerifiedTransaction, transaction_effects: &TransactionEffects, )

fn multi_insert_transaction_and_effects( &self, transactions_and_effects: &[VerifiedExecutionData], )

impl TestingAPI for WritebackCache

fn database_for_testing(&self) -> Arc<AuthorityStore>

impl TransactionCacheRead for WritebackCache

fn multi_get_transaction_blocks( &self, digests: &[TransactionDigest], ) -> Vec<Option<Arc<VerifiedTransaction>>>

fn multi_get_executed_effects_digests( &self, digests: &[TransactionDigest], ) -> Vec<Option<TransactionEffectsDigest>>

fn multi_get_effects( &self, digests: &[TransactionEffectsDigest], ) -> Vec<Option<TransactionEffects>>

fn notify_read_executed_effects_digests<'a>( &'a self, digests: &'a [TransactionDigest], ) -> BoxFuture<'a, Vec<TransactionEffectsDigest>>

fn multi_get_events( &self, event_digests: &[TransactionDigest], ) -> Vec<Option<TransactionEvents>>

fn get_transaction_block( &self, digest: &TransactionDigest, ) -> Option<Arc<VerifiedTransaction>>

fn get_transactions_and_serialized_sizes( &self, digests: &[TransactionDigest], ) -> SuiResult<Vec<Option<(VerifiedTransaction, usize)>>>

fn is_tx_already_executed(&self, digest: &TransactionDigest) -> bool

fn multi_get_executed_effects( &self, digests: &[TransactionDigest], ) -> Vec<Option<TransactionEffects>>

fn get_executed_effects( &self, digest: &TransactionDigest, ) -> Option<TransactionEffects>

fn get_effects( &self, digest: &TransactionEffectsDigest, ) -> Option<TransactionEffects>

fn get_events(&self, digest: &TransactionDigest) -> Option<TransactionEvents>

fn notify_read_executed_effects<'a>( &'a self, digests: &'a [TransactionDigest], ) -> BoxFuture<'a, Vec<TransactionEffects>>

Wait until the effects of the given transactions are available and return them. WARNING: If calling this on a transaction that could be reverted, you must be sure that this function cannot be called during reconfiguration. The best way to do this is to wrap your future in EpochStore::within_alive_epoch. Holding an ExecutionLockReadGuard would also prevent reconfig from happening while waiting, but this is very dangerous, as it could prevent reconfiguration from ever occurring!

impl ExecutionCacheAPI for WritebackCache