Struct sui_core::execution_cache::passthrough_cache::PassthroughCache

pub struct PassthroughCache { /* private fields */ }

Implementations

impl PassthroughCache

pub fn new( store: Arc<AuthorityStore>, metrics: Arc<ExecutionCacheMetrics> ) -> Self

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

pub fn as_notify_read_wrapper(self: Arc<Self>) -> NotifyReadWrapper<Self>

pub fn store_for_testing(&self) -> &Arc<AuthorityStore>

pub async fn prune_objects_and_compact_for_testing( &self, checkpoint_store: &Arc<CheckpointStore> )

Trait Implementations

impl AccumulatorStore for PassthroughCache

fn get_object_ref_prior_to_key_deprecated( &self, object_id: &ObjectID, version: VersionNumber ) -> 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 PassthroughCache

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

impl CheckpointCache for PassthroughCache

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

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

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

impl ChildObjectResolver for PassthroughCache

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 PassthroughCache

fn commit_transaction_outputs<'a>( &'a self, _epoch: EpochId, _digests: &'a [TransactionDigest] ) -> BoxFuture<'a, SuiResult>

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_transactions( &self, _digests: &[TransactionDigest] ) -> BoxFuture<'_, SuiResult>

Durably commit transactions (but not their outputs) to the database. Called before writing a locally built checkpoint to the CheckpointStore, so that the inputs of the checkpoint cannot be lost. These transactions are guaranteed to be final unless this validator forks (i.e. constructs a checkpoint which will never be certified). In this case some non-final transactions could be left in the database.

impl ExecutionCacheRead for PassthroughCache

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) -> SuiResult<Option<Object>>

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

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

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

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

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

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

fn find_object_lt_or_eq_version( &self, object_id: ObjectID, version: SequenceNumber ) -> SuiResult<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_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 multi_get_transaction_blocks( &self, digests: &[TransactionDigest] ) -> SuiResult<Vec<Option<Arc<VerifiedTransaction>>>>

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

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

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

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

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

fn get_marker_value( &self, object_id: &ObjectID, version: SequenceNumber, epoch_id: EpochId ) -> SuiResult<Option<MarkerValue>>

Get the marker at a specific version

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

Get the latest marker for a given object.

fn get_objects(&self, objects: &[ObjectID]) -> SuiResult<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 ) -> Result<Vec<bool>, SuiError>

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_transaction_block( &self, digest: &TransactionDigest ) -> SuiResult<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) -> SuiResult<bool>

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

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

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

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

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

fn get_last_shared_object_deletion_info( &self, object_id: &ObjectID, epoch_id: EpochId ) -> SuiResult<Option<(SequenceNumber, TransactionDigest)>>

If the shared object was deleted, return deletion info for the current live version

fn get_deleted_shared_object_previous_tx_digest( &self, object_id: &ObjectID, version: SequenceNumber, epoch_id: EpochId ) -> SuiResult<Option<TransactionDigest>>

If the shared object was deleted, return deletion info for the specified version.

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

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

impl ExecutionCacheReconfigAPI for PassthroughCache

fn insert_genesis_object(&self, object: Object) -> SuiResult

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

fn revert_state_update(&self, digest: &TransactionDigest) -> SuiResult

fn set_epoch_start_configuration( &self, epoch_start_config: &EpochStartConfiguration ) -> SuiResult

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.

impl ExecutionCacheWrite for PassthroughCache

fn write_transaction_outputs<'a>( &'a self, epoch_id: EpochId, tx_outputs: Arc<TransactionOutputs> ) -> BoxFuture<'a, SuiResult>

Write the output of a transaction.

fn acquire_transaction_locks<'a>( &'a self, epoch_store: &'a AuthorityPerEpochStore, owned_input_objects: &'a [ObjectRef], transaction: VerifiedSignedTransaction ) -> BoxFuture<'a, SuiResult>

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

impl ObjectStore for PassthroughCache

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

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

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

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

impl ParentSync for PassthroughCache

fn get_latest_parent_entry_ref_deprecated( &self, object_id: ObjectID ) -> SuiResult<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 PassthroughCache

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

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