Struct solana_runtime::accounts::Accounts[][src]

pub struct Accounts {
    pub slot: Slot,
    pub epoch: Epoch,
    pub accounts_db: Arc<AccountsDb>,
    // some fields omitted
}

This structure handles synchronization for db

Fields

slot: Slot

my slot

epoch: Epoch

my epoch

accounts_db: Arc<AccountsDb>

Single global AccountsDb

Implementations

impl Accounts[src]

pub fn new(paths: Vec<PathBuf>, cluster_type: &ClusterType) -> Self[src]

pub fn new_with_config(
    paths: Vec<PathBuf>,
    cluster_type: &ClusterType,
    account_indexes: HashSet<AccountIndex>,
    caching_enabled: bool
) -> Self
[src]

pub fn new_from_parent(
    parent: &Accounts,
    slot: Slot,
    parent_slot: Slot,
    epoch: Epoch
) -> Self
[src]

pub fn has_duplicates<T: PartialEq>(xs: &[T]) -> bool[src]

Return true if the slice has any duplicate elements

pub fn load_accounts(
    &self,
    ancestors: &Ancestors,
    txs: &[Transaction],
    txs_iteration_order: Option<&[usize]>,
    lock_results: Vec<TransactionCheckResult>,
    hash_queue: &BlockhashQueue,
    error_counters: &mut ErrorCounters,
    rent_collector: &RentCollector,
    feature_set: &FeatureSet
) -> Vec<TransactionLoadResult>
[src]

pub fn load_slow(
    &self,
    ancestors: &Ancestors,
    pubkey: &Pubkey
) -> Option<(Account, Slot)>
[src]

Slow because lock is held for 1 operation instead of many

pub fn scan_slot<F, B>(&self, slot: Slot, func: F) -> Vec<B> where
    F: Fn(LoadedAccount<'_>) -> Option<B> + Send + Sync,
    B: Sync + Send + Default + Eq
[src]

scans underlying accounts_db for this delta (slot) with a map function from LoadedAccount to B returns only the latest/current version of B for this slot

pub fn load_by_program_slot(
    &self,
    slot: Slot,
    program_id: Option<&Pubkey>
) -> Vec<(Pubkey, Account)>
[src]

pub fn load_largest_accounts(
    &self,
    ancestors: &Ancestors,
    num: usize,
    filter_by_address: &HashSet<Pubkey>,
    filter: AccountAddressFilter
) -> Vec<(Pubkey, u64)>
[src]

pub fn calculate_capitalization(
    &self,
    ancestors: &Ancestors,
    simple_capitalization_enabled: bool
) -> u64
[src]

#[must_use]pub fn verify_bank_hash_and_lamports(
    &self,
    slot: Slot,
    ancestors: &Ancestors,
    total_lamports: u64,
    simple_capitalization_enabled: bool
) -> bool
[src]

pub fn load_by_program(
    &self,
    ancestors: &Ancestors,
    program_id: &Pubkey
) -> Vec<(Pubkey, Account)>
[src]

pub fn load_by_program_with_filter<F: Fn(&Account) -> bool>(
    &self,
    ancestors: &Ancestors,
    program_id: &Pubkey,
    filter: F
) -> Vec<(Pubkey, Account)>
[src]

pub fn load_by_index_key_with_filter<F: Fn(&Account) -> bool>(
    &self,
    ancestors: &Ancestors,
    index_key: &IndexKey,
    filter: F
) -> Vec<(Pubkey, Account)>
[src]

pub fn load_all(&self, ancestors: &Ancestors) -> Vec<(Pubkey, Account, Slot)>[src]

pub fn load_to_collect_rent_eagerly<R: RangeBounds<Pubkey>>(
    &self,
    ancestors: &Ancestors,
    range: R
) -> Vec<(Pubkey, Account)>
[src]

pub fn store_slow_uncached(
    &self,
    slot: Slot,
    pubkey: &Pubkey,
    account: &Account
)
[src]

Slow because lock is held for 1 operation instead of many. WARNING: This noncached version is only to be used for tests/benchmarking as bypassing the cache in general is not supported

pub fn store_slow_cached(&self, slot: Slot, pubkey: &Pubkey, account: &Account)[src]

pub fn bank_hash_at(&self, slot: Slot) -> Hash[src]

pub fn bank_hash_info_at(&self, slot: Slot) -> BankHashInfo[src]

#[must_use]pub fn lock_accounts(
    &self,
    txs: &[Transaction],
    txs_iteration_order: Option<&[usize]>
) -> Vec<Result<()>>
[src]

This function will prevent multiple threads from modifying the same account state at the same time

pub fn unlock_accounts(
    &self,
    txs: &[Transaction],
    txs_iteration_order: Option<&[usize]>,
    results: &[Result<()>]
)
[src]

Once accounts are unlocked, new transactions that modify that state can enter the pipeline

pub fn store_cached(
    &self,
    slot: Slot,
    txs: &[Transaction],
    txs_iteration_order: Option<&[usize]>,
    res: &[TransactionExecutionResult],
    loaded: &mut [TransactionLoadResult],
    rent_collector: &RentCollector,
    last_blockhash_with_fee_calculator: &(Hash, FeeCalculator),
    fix_recent_blockhashes_sysvar_delay: bool
)
[src]

Store the accounts into the DB

pub fn purge_slot(&self, slot: Slot)[src]

Purge a slot if it is not a root Root slots cannot be purged

pub fn add_root(&self, slot: Slot)[src]

Add a slot to root. Root slots cannot be purged

Trait Implementations

impl Debug for Accounts[src]

impl Default for Accounts[src]

Auto Trait Implementations

impl !RefUnwindSafe for Accounts

impl Send for Accounts

impl Sync for Accounts

impl Unpin for Accounts

impl !UnwindSafe for Accounts

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T> Instrument for T[src]

impl<T> Instrument for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> MaybeDebug for T where
    T: Debug
[src]

impl<T> Pointable for T[src]

type Init = T

The type for initializers.

impl<T> Same<T> for T[src]

type Output = T

Should always be Self

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Typeable for T where
    T: Any

impl<V, T> VZip<V> for T where
    V: MultiLane<T>, 
[src]

impl<T> WithSubscriber for T[src]