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>) -> Self

pub fn evict_executed_effects_from_cache_for_testing( &self, tx_digest: &TransactionDigest, )

pub fn clear_caches_and_assert_empty(&self)

Trait Implementations

impl AccountFundsRead for WritebackCache

fn get_latest_account_amount(&self, account_id: &AccumulatorObjId) -> u128

Gets the latest amount in an account. If the account does not exist, returns 0. This does an unsequenced read and does not guarantee consistency with the root accumulator version.

fn get_consistent_latest_account_amount_and_version( &self, account_id: &AccumulatorObjId, ) -> (u128, SequenceNumber)

Gets the account amount at a version consistent with a stable accumulator root version. If the account object has advanced ahead of that root version, this returns the amount at or before the root version instead of the latest account object amount. If the account does not exist at that root version, returns 0 for the amount. It guarantees no data race between the read of the account object and the root accumulator version.

fn get_account_amount_at_version( &self, account_id: &AccumulatorObjId, version: SequenceNumber, ) -> u128

Read the amount at a precise version. Care must be taken to only call this function if we can guarantee that objects behind this version have not yet been pruned.

fn check_amounts_available( &self, requested_amounts: &BTreeMap<AccumulatorObjId, (u64, TypeTag)>, ) -> SuiResult

Checks if given amounts are available in the latest versions of the referenced acccumulator objects. This does un-sequenced reads and can only be used on the signing/voting path where deterministic results are not required.

fn check_remaining_amounts_after_withdrawal( &self, requested_amounts: &BTreeMap<AccumulatorObjId, (u64, TypeTag)>, min_amounts: &BTreeMap<TypeTag, u64>, ) -> SuiResult

For gasless transactions, checks that withdrawing the requested amounts does not leave a balance below the minimum in the sender’s account. For each withdrawal, the remaining balance (actual - requested) must be either 0 or >= the minimum transfer amount for that token type.

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 set_highest_committed_checkpoint_in_batch( &self, batch: &mut Batch, checkpoint: CheckpointSequenceNumber, )

Stage the highest-committed-checkpoint watermark into batch so it is written atomically with that checkpoint’s transaction outputs. Called by CheckpointExecutor between Self::build_db_batch and Self::commit_transaction_outputs. Unlike the checkpoint store’s separately-bumped highest_executed watermark, this stays consistent with the durable object set across an unclean stop.

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 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 validate_owned_object_versions( &self, owned_input_objects: &[ObjectRef], ) -> SuiResult

Validate owned object versions and digests without acquiring locks. Used to validate transaction input before submitting or voting to accept the transaction.

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

Write the output of a transaction.

impl GlobalStateHashStore 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_hash_for_epoch( &self, epoch: EpochId, ) -> SuiResult<Option<(CheckpointSequenceNumber, GlobalStateHash)>>

fn get_root_state_hash_for_highest_epoch( &self, ) -> SuiResult<Option<(EpochId, (CheckpointSequenceNumber, GlobalStateHash))>>

fn insert_state_hash_for_epoch( &self, epoch: EpochId, checkpoint_seq_num: &CheckpointSequenceNumber, acc: &GlobalStateHash, ) -> 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 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 multi_input_objects_available_cache_only( &self, keys: &[InputKey], ) -> Vec<bool>

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 notify_read_input_objects<'a>( &'a self, input_and_receiving_keys: &'a [InputKey], receiving_keys: &'a HashSet<InputKey>, epoch: EpochId, ) -> BoxFuture<'a, ()>

Given a list of input and receiving objects for a transaction, wait until all of them become available, so that the transaction can start execution. input_and_receiving_keys contains both input objects and receiving input objects, including canceled objects. TODO: Eventually this can return the objects read results, so that execution does not need to load them again.

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 execution scheduler 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>

fn cache_for_testing(&self) -> &WritebackCache

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 transaction_executed_in_last_epoch( &self, digest: &TransactionDigest, current_epoch: EpochId, ) -> bool

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

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

fn get_unchanged_loaded_runtime_objects( &self, digest: &TransactionDigest, ) -> Option<Vec<ObjectKey>>

fn take_accumulator_events( &self, digest: &TransactionDigest, ) -> Option<Vec<AccumulatorEvent>>

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

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, task_name: &'static str, 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!

fn notify_read_executed_effects_may_fail<'a>( &'a self, task_name: &'static str, digests: &'a [TransactionDigest], ) -> BoxFuture<'a, SuiResult<Vec<TransactionEffects>>>

Returns an error if any of the requested effects have been pruned from the database. Use this in non-critical paths where effects may not exist (e.g., serving historical data that may have been pruned). For critical paths where effects must exist, use notify_read_executed_effects.

impl ExecutionCacheAPI for WritebackCache