Struct solana_runtime::accounts::Accounts

pub struct Accounts {
    pub accounts_db: Arc<AccountsDB>,
    // some fields omitted
}

This structure handles synchronization for db

Fields

accounts_db: Arc<AccountsDB>

Single global AccountsDB

Methods

impl Accounts

pub fn new(paths: Option<String>) -> Self

pub fn new_from_parent(parent: &Accounts) -> Self

pub fn update_from_stream<R: Read>(
    &self,
    stream: &mut BufReader<R>
) -> Result<(), Error>

pub fn load_accounts(
    &self,
    ancestors: &HashMap<Fork, usize>,
    txs: &[Transaction],
    lock_results: Vec<Result<()>>,
    hash_queue: &BlockhashQueue,
    error_counters: &mut ErrorCounters
) -> Vec<Result<(InstructionAccounts, InstructionLoaders, InstructionCredits)>>

pub fn load_slow(
    &self,
    ancestors: &HashMap<Fork, usize>,
    pubkey: &Pubkey
) -> Option<(Account, Fork)>

Slow because lock is held for 1 operation instead of many

pub fn load_by_program_fork(
    &self,
    fork: Fork,
    program_id: &Pubkey
) -> Vec<(Pubkey, Account)>

pub fn load_by_program(
    &self,
    ancestors: &HashMap<Fork, usize>,
    program_id: &Pubkey
) -> Vec<(Pubkey, Account)>

pub fn store_slow(&self, fork: Fork, pubkey: &Pubkey, account: &Account)

Slow because lock is held for 1 operation instead of many

pub fn hash_internal_state(&self, fork_id: Fork) -> Option<Hash>

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

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

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

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

pub fn has_accounts(&self, fork: Fork) -> bool

pub fn store_accounts(
    &self,
    fork: Fork,
    txs: &[Transaction],
    res: &[Result<()>],
    loaded: &mut [Result<(InstructionAccounts, InstructionLoaders, InstructionCredits)>]
)

Store the accounts into the DB

pub fn purge_fork(&self, fork: Fork)

Purge a fork if it is not a root Root forks cannot be purged

pub fn add_root(&self, fork: Fork)

Add a fork to root. Root forks cannot be purged

pub fn commit_credits(&self, ancestors: &HashMap<Fork, usize>, fork: Fork)

Commit remaining credit-only changes, regardless of reference count

We do a take() on self.credit_only_account_locks so that the hashmap is no longer available to be written to. This prevents any transactions from reinserting into the hashmap. Then there are then only 2 cases for interleaving with commit_credits and lock_accounts. Either:

pub fn commit_credits_unsafe(
    &self,
    ancestors: &HashMap<Fork, usize>,
    fork: Fork
)

Used only for tests to store credit-only accounts after every transaction

Trait Implementations

impl Default for Accounts

fn default() -> Accounts

Returns the "default value" for a type.

impl Debug for Accounts

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

Formats the value using the given formatter.