Struct solana_runtime::accounts_db::AccountsDb

pub struct AccountsDb {

    pub accounts_index: AccountsIndex<AccountInfo>,
    pub storage: AccountStorage,
    pub accounts_cache: AccountsCache,
    pub next_id: AtomicUsize,
    pub shrink_candidate_slots: Mutex<HashMap<Slot, HashMap<AppendVecId, Arc<AccountStorageEntry>>>>,
    pub shrink_candidate_slots_v1: Mutex<Vec<Slot>>,
    pub shrink_paths: RwLock<Option<Vec<PathBuf>>>,
    pub thread_pool: ThreadPool,
    pub thread_pool_clean: ThreadPool,
    pub bank_hashes: RwLock<HashMap<Slot, BankHashInfo>>,
    pub cluster_type: Option<ClusterType>,
    pub account_indexes: AccountSecondaryIndexes,
    pub caching_enabled: bool,
    pub filler_account_suffix: Option<Pubkey>,
    pub num_hash_scan_passes: Option<usize>,
    /* private fields */
}

Fields

accounts_index: AccountsIndex<AccountInfo>

Keeps tracks of index into AppendVec on a per slot basis

storage: AccountStorage

accounts_cache: AccountsCache

next_id: AtomicUsize

distribute the accounts across storage lists

shrink_candidate_slots: Mutex<HashMap<Slot, HashMap<AppendVecId, Arc<AccountStorageEntry>>>>

Set of shrinkable stores organized by map of slot to append_vec_id

shrink_candidate_slots_v1: Mutex<Vec<Slot>>

Legacy shrink slots to support non-cached code-path.

shrink_paths: RwLock<Option<Vec<PathBuf>>>

thread_pool: ThreadPool

Thread pool used for par_iter

thread_pool_clean: ThreadPool

bank_hashes: RwLock<HashMap<Slot, BankHashInfo>>

cluster_type: Option<ClusterType>

account_indexes: AccountSecondaryIndexes

caching_enabled: bool

filler_account_suffix: Option<Pubkey>

num_hash_scan_passes: Option<usize>

Implementations

impl AccountsDb

pub fn notify_account_restore_from_snapshot(&self)

Notify the plugins of of account data when AccountsDb is restored from a snapshot. The data is streamed in the reverse order of the slots so that an account is only streamed once. At a slot, if the accounts is updated multiple times only the last write (with highest write_version) is notified.

pub fn notify_account_at_accounts_update(
    &self,
    slot: Slot,
    meta: &StoredMeta,
    account: &AccountSharedData
)

impl AccountsDb

pub fn default_for_tests() -> Self

pub fn new_for_tests(paths: Vec<PathBuf>, cluster_type: &ClusterType) -> Self

pub fn new_for_tests_with_caching(
    paths: Vec<PathBuf>,
    cluster_type: &ClusterType
) -> Self

pub fn new_with_config(
    paths: Vec<PathBuf>,
    cluster_type: &ClusterType,
    account_indexes: AccountSecondaryIndexes,
    caching_enabled: bool,
    shrink_ratio: AccountShrinkThreshold,
    accounts_db_config: Option<AccountsDbConfig>,
    accounts_update_notifier: Option<AccountsUpdateNotifier>
) -> Self

pub fn set_shrink_paths(&self, paths: Vec<PathBuf>)

pub fn file_size(&self) -> u64

pub fn new_single_for_tests() -> Self

pub fn new_single_for_tests_with_caching() -> Self

pub fn expected_cluster_type(&self) -> ClusterType

pub fn clean_accounts(
    &self,
    max_clean_root: Option<Slot>,
    is_startup: bool,
    last_full_snapshot_slot: Option<Slot>
)

pub fn shrink_candidate_slots(&self) -> usize

pub fn shrink_all_slots(
    &self,
    is_startup: bool,
    last_full_snapshot_slot: Option<Slot>
)

pub fn scan_accounts<F, A>(
    &self,
    ancestors: &Ancestors,
    bank_id: BankId,
    scan_func: F,
    config: &ScanConfig
) -> ScanResult<A> where
    F: Fn(&mut A, Option<(&Pubkey, AccountSharedData, Slot)>),
    A: Default, 

pub fn unchecked_scan_accounts<F, A>(
    &self,
    metric_name: &'static str,
    ancestors: &Ancestors,
    scan_func: F,
    config: &ScanConfig
) -> A where
    F: Fn(&mut A, (&Pubkey, LoadedAccount<'_>, Slot)),
    A: Default, 

pub fn range_scan_accounts<F, A, R>(
    &self,
    metric_name: &'static str,
    ancestors: &Ancestors,
    range: R,
    config: &ScanConfig,
    scan_func: F
) -> A where
    F: Fn(&mut A, Option<(&Pubkey, AccountSharedData, Slot)>),
    A: Default,
    R: RangeBounds<Pubkey> + Debug, 

pub fn index_scan_accounts<F, A>(
    &self,
    ancestors: &Ancestors,
    bank_id: BankId,
    index_key: IndexKey,
    scan_func: F,
    config: &ScanConfig
) -> ScanResult<(A, bool)> where
    F: Fn(&mut A, Option<(&Pubkey, AccountSharedData, Slot)>),
    A: Default, 

pub fn scan_account_storage<R, B>(
    &self,
    slot: Slot,
    cache_map_func: impl Fn(LoadedAccount<'_>) -> Option<R> + Sync,
    storage_scan_func: impl Fn(&B, LoadedAccount<'_>) + Sync
) -> ScanStorageResult<R, B> where
    R: Send,
    B: Send + Default + Sync, 

Scan a specific slot through all the account storage in parallel

pub fn set_hash(&self, slot: Slot, parent_slot: Slot)

pub fn load(
    &self,
    ancestors: &Ancestors,
    pubkey: &Pubkey,
    load_hint: LoadHint
) -> Option<(AccountSharedData, Slot)>

pub fn load_with_fixed_root(
    &self,
    ancestors: &Ancestors,
    pubkey: &Pubkey
) -> Option<(AccountSharedData, Slot)>

pub fn load_without_fixed_root(
    &self,
    ancestors: &Ancestors,
    pubkey: &Pubkey
) -> Option<(AccountSharedData, Slot)>

pub fn load_account_hash(
    &self,
    ancestors: &Ancestors,
    pubkey: &Pubkey,
    max_root: Option<Slot>,
    load_hint: LoadHint
) -> Option<Hash>

pub fn create_drop_bank_callback(
    &self,
    pruned_banks_sender: DroppedSlotsSender
) -> SendDroppedBankCallback

pub fn purge_slot(&self, slot: Slot, bank_id: BankId, is_from_abs: bool)

This should only be called after the Bank::drop() runs in bank.rs, See BANK_DROP_SAFETY comment below for more explanation. is_from_abs is true if the caller is the AccountsBackgroundService

pub fn remove_unrooted_slots(&self, remove_slots: &[(Slot, BankId)])

pub fn hash_stored_account(slot: Slot, account: &StoredAccountMeta<'_>) -> Hash

pub fn hash_account<T: ReadableAccount>(
    slot: Slot,
    account: &T,
    pubkey: &Pubkey
) -> Hash

pub fn mark_slot_frozen(&self, slot: Slot)

pub fn expire_old_recycle_stores(&self)

pub fn flush_accounts_cache_slot(&self, slot: Slot)

pub fn flush_accounts_cache(
    &self,
    force_flush: bool,
    requested_flush_root: Option<Slot>
)

pub fn checked_iterative_sum_for_capitalization(
    total_cap: u64,
    new_cap: u64
) -> u64

pub fn checked_sum_for_capitalization<T: Iterator<Item = u64>>(
    balances: T
) -> u64

pub fn get_accounts_hash(&self, slot: Slot) -> Hash

pub fn update_accounts_hash(
    &self,
    slot: Slot,
    ancestors: &Ancestors
) -> (Hash, u64)

pub fn update_accounts_hash_test(
    &self,
    slot: Slot,
    ancestors: &Ancestors
) -> (Hash, u64)

pub fn update_accounts_hash_with_index_option(
    &self,
    use_index: bool,
    debug_verify: bool,
    slot: Slot,
    ancestors: &Ancestors,
    expected_capitalization: Option<u64>,
    can_cached_slot_be_unflushed: bool,
    slots_per_epoch: Option<Slot>,
    is_startup: bool
) -> (Hash, u64)

pub fn calculate_accounts_hash_without_index(
    accounts_hash_cache_path: &Path,
    storages: &SortedStorages<'_>,
    thread_pool: Option<&ThreadPool>,
    stats: HashStats,
    check_hash: bool,
    accounts_cache_and_ancestors: Option<(&AccountsCache, &Ancestors, &AccountsIndex<AccountInfo>)>,
    filler_account_suffix: Option<&Pubkey>,
    num_hash_scan_passes: Option<usize>
) -> Result<(Hash, u64), BankHashVerificationError>

pub fn verify_bank_hash_and_lamports(
    &self,
    slot: Slot,
    ancestors: &Ancestors,
    total_lamports: u64,
    test_hash_calculation: bool
) -> Result<(), BankHashVerificationError>

Only called from startup or test code.

pub fn scan_slot_and_insert_dirty_pubkeys_into_uncleaned_pubkeys(
    &self,
    slot: Slot
)

Scan a slot in the account storage for dirty pubkeys and insert them into the list of uncleaned pubkeys

This function is called in Bank::drop() when the bank is not frozen, so that its pubkeys are considered for cleanup.

pub fn get_accounts_delta_hash(&self, slot: Slot) -> Hash

pub fn store_cached(
    &self,
    slot: Slot,
    accounts: &[(&Pubkey, &AccountSharedData)]
)

pub fn store_uncached(
    &self,
    slot: Slot,
    accounts: &[(&Pubkey, &AccountSharedData)]
)

Store the account update. only called by tests

pub fn add_root(&self, slot: Slot) -> AccountsAddRootTiming

pub fn get_snapshot_storages(
    &self,
    snapshot_slot: Slot,
    snapshot_base_slot: Option<Slot>,
    ancestors: Option<&Ancestors>
) -> (SnapshotStorages, Vec<Slot>)

pub fn is_filler_account_helper(
    pubkey: &Pubkey,
    filler_account_suffix: Option<&Pubkey>
) -> bool

pub fn is_filler_account(&self, pubkey: &Pubkey) -> bool

true if ‘pubkey’ is a filler account

pub fn filler_accounts_enabled(&self) -> bool

true if it is possible that there are filler accounts present

pub fn maybe_add_filler_accounts(&self, epoch_schedule: &EpochSchedule)

filler accounts are space-holding accounts which are ignored by hash calculations and rent. They are designed to allow a validator to run against a network successfully while simulating having many more accounts present. All filler accounts share a common pubkey suffix. The suffix is randomly generated per validator on startup. The filler accounts are added to each slot in the snapshot after index generation. The accounts added in a slot are setup to have pubkeys such that rent will be collected from them before (or when?) their slot becomes an epoch old. Thus, the filler accounts are rewritten by rent and the old slot can be thrown away successfully.

pub fn generate_index(
    &self,
    limit_load_slot_count_from_snapshot: Option<usize>,
    verify: bool,
    genesis_config: &GenesisConfig
) -> IndexGenerationInfo

impl AccountsDb

Legacy shrink functions to support non-cached path. Should be able to be deleted after cache path is the only path.

pub fn process_stale_slot_v1(&self) -> usize

Trait Implementations

impl Debug for AccountsDb

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.