Struct solana_runtime::bucket_map_holder::BucketMapHolder

pub struct BucketMapHolder<T: IndexValue, U: DiskIndexValue + From<T> + Into<T>> {

    pub disk: Option<BucketMap<(Slot, U)>>,
    pub count_buckets_flushed: AtomicUsize,
    pub age: AtomicU8,
    pub future_age_to_flush: AtomicU8,
    pub future_age_to_flush_cached: AtomicU8,
    pub stats: BucketMapHolderStats,
    age_timer: AtomicInterval,
    pub wait_dirty_or_aged: Arc<WaitableCondvar>,
    next_bucket_to_flush: AtomicUsize,
    bins: usize,
    pub threads: usize,
    pub mem_budget_mb: Option<usize>,
    pub ages_to_stay_in_cache: Age,
    startup: AtomicBool,
    _phantom: PhantomData<T>,
}

Fields

disk: Option<BucketMap<(Slot, U)>>

count_buckets_flushed: AtomicUsize

age: AtomicU8

These three ages are individual atomics because their values are read many times from code during runtime. Instead of accessing the single age and doing math each time, each value is incremented each time the age occurs, which is ~400ms. Callers can ask for the precomputed value they already want. rolling ‘current’ age

future_age_to_flush: AtomicU8

rolling age that is ‘ages_to_stay_in_cache’ + ‘age’

future_age_to_flush_cached: AtomicU8

rolling age that is effectively ‘age’ - 1 these items are expected to be flushed from the accounts write cache or otherwise modified before this age occurs

stats: BucketMapHolderStats

age_timer: AtomicInterval

wait_dirty_or_aged: Arc<WaitableCondvar>

next_bucket_to_flush: AtomicUsize

bins: usize

threads: usize

mem_budget_mb: Option<usize>

ages_to_stay_in_cache: Age

how many ages should elapse from the last time an item is used where the item will remain in the cache

startup: AtomicBool

startup is a special time for flush to focus on moving everything to disk as fast and efficiently as possible with less thread count limitations. LRU and access patterns are not important. Freeing memory and writing to disk in parallel are. Note startup is an optimization and is not required for correctness.

_phantom: PhantomData<T>

Implementations

impl<T: IndexValue, U: DiskIndexValue + From<T> + Into<T>> BucketMapHolder<T, U>

pub fn is_disk_index_enabled(&self) -> bool

is the accounts index using disk as a backing store

pub fn increment_age(&self)

pub fn future_age_to_flush(&self, is_cached: bool) -> Age

fn has_age_interval_elapsed(&self) -> bool

pub fn get_startup(&self) -> bool

used by bg processes to determine # active threads and how aggressively to flush

pub fn set_startup(&self, value: bool)

startup=true causes: in mem to act in a way that flushes to disk asap startup=false is ‘normal’ operation

pub(crate) fn wait_for_idle(&self)

return when the bg threads have reached an ‘idle’ state

pub fn current_age(&self) -> Age

pub fn bucket_flushed_at_current_age(&self, can_advance_age: bool)

pub fn all_buckets_flushed_at_current_age(&self) -> bool

have all buckets been flushed at the current age?

fn all_buckets_flushed_at_current_age_internal( &self, count_buckets_flushed: usize ) -> bool

have all buckets been flushed at the current age?

pub fn count_buckets_flushed(&self) -> usize

pub fn maybe_advance_age(&self) -> bool

if all buckets are flushed at the current age and time has elapsed, then advance age

fn maybe_advance_age_internal( &self, all_buckets_flushed_at_current_age: bool ) -> bool

if all buckets are flushed at the current age and time has elapsed, then advance age

pub fn new( bins: usize, config: &Option<AccountsIndexConfig>, threads: usize ) -> Self

pub fn next_bucket_to_flush(&self) -> usize

fn age_interval_ms(&self) -> u64

prepare for this to be dynamic if necessary For example, maybe startup has a shorter age interval.

fn throttling_wait_ms_internal( &self, interval_ms: u64, elapsed_ms: u64, bins_flushed: u64 ) -> Option<u64>

return an amount of ms to sleep

fn throttling_wait_ms(&self) -> Option<u64>

Check progress this age. Return ms to wait to get closer to the wait target and spread out work over the entire age interval. Goal is to avoid cpu spikes at beginning of age interval.

fn should_thread_sleep(&self) -> bool

true if this thread can sleep

pub fn background( &self, exit: Vec<Arc<AtomicBool>>, in_mem: Vec<Arc<InMemAccountsIndex<T, U>>>, can_advance_age: bool )

Trait Implementations

impl<T: IndexValue, U: DiskIndexValue + From<T> + Into<T>> Debug for BucketMapHolder<T, U>

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

Formats the value using the given formatter.