Struct solana_runtime::accounts_db::AccountsDB

pub struct AccountsDB {
    pub accounts_index: RwLock<AccountsIndex<AccountInfo>>,
    pub storage: RwLock<AccountStorage>,
    pub next_id: AtomicUsize,
    pub shrink_candidate_slots: Mutex<Vec<Slot>>,
    pub thread_pool: ThreadPool,
    pub thread_pool_clean: ThreadPool,
    pub bank_hashes: RwLock<HashMap<Slot, BankHashInfo>>,
    pub cluster_type: Option<ClusterType>,
    // some fields omitted
}

Fields

accounts_index: RwLock<AccountsIndex<AccountInfo>>

Keeps tracks of index into AppendVec on a per slot basis

storage: RwLock<AccountStorage>

next_id: AtomicUsize

distribute the accounts across storage lists

shrink_candidate_slots: Mutex<Vec<Slot>>

thread_pool: ThreadPool

Thread pool used for par_iter

thread_pool_clean: ThreadPool

bank_hashes: RwLock<HashMap<Slot, BankHashInfo>>

cluster_type: Option<ClusterType>

Implementations

impl AccountsDB

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

pub fn clean_accounts(&self)

pub fn process_dead_slots<'a>(
    &'a self,
    dead_slots_w: Option<RwLockWriteGuard<'a, HashSet<Slot>>>
)

pub fn process_stale_slot(&self) -> usize

pub fn shrink_all_slots(&self)

pub fn scan_accounts<F, A>(&self, ancestors: &Ancestors, scan_func: F) -> A where
    F: Fn(&mut A, Option<(&Pubkey, Account, Slot)>),
    A: Default, 

pub fn range_scan_accounts<F, A, R>(
    &self,
    ancestors: &Ancestors,
    range: R,
    scan_func: F
) -> A where
    F: Fn(&mut A, Option<(&Pubkey, Account, Slot)>),
    A: Default,
    R: RangeBounds<Pubkey>, 

pub fn scan_account_storage<F, B>(&self, slot: Slot, scan_func: F) -> Vec<B> where
    F: Fn(&StoredAccount<'_>, AppendVecId, &mut B) + Send + Sync,
    B: Send + Default, 

Scan a specific slot through all the account storage in parallel with sequential read

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

pub fn load(
    storage: &AccountStorage,
    ancestors: &Ancestors,
    accounts_index: &AccountsIndex<AccountInfo>,
    pubkey: &Pubkey
) -> Option<(Account, Slot)>

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

pub fn purge_slot(&self, slot: Slot)

pub fn purge_slots(&self, slots: &HashSet<Slot>)

pub fn remove_unrooted_slot(&self, remove_slot: Slot)

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

pub fn hash_account(
    slot: Slot,
    account: &Account,
    pubkey: &Pubkey,
    cluster_type: &ClusterType
) -> Hash

pub fn hash_account_data(
    slot: Slot,
    lamports: u64,
    owner: &Pubkey,
    executable: bool,
    rent_epoch: Epoch,
    data: &[u8],
    pubkey: &Pubkey,
    include_owner: bool
) -> Hash

pub fn blake3_hash_account_data(
    slot: Slot,
    lamports: u64,
    owner: &Pubkey,
    executable: bool,
    rent_epoch: Epoch,
    data: &[u8],
    pubkey: &Pubkey,
    include_owner: bool
) -> Hash

pub fn compute_merkle_root(
    hashes: Vec<(Pubkey, Hash, u64)>,
    fanout: usize
) -> Hash

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

pub fn account_balance_for_capitalization(
    lamports: u64,
    owner: &Pubkey,
    executable: bool
) -> u64

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

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

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

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

pub fn clean_dead_slots(&self, dead_slots: &HashSet<Slot>)

pub fn store(&self, slot: Slot, accounts: &[(&Pubkey, &Account)])

Store the account update.

pub fn add_root(&self, slot: Slot)

pub fn get_snapshot_storages(&self, snapshot_slot: Slot) -> SnapshotStorages

pub fn generate_index(&self)

Trait Implementations

impl Debug for AccountsDB

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

Formats the value using the given formatter.

impl Default for AccountsDB

fn default() -> Self

Returns the "default value" for a type.