Struct InMemAccountsIndex

pub struct InMemAccountsIndex<T: IndexValue, U: DiskIndexValue + From<T> + Into<T>> {
    pub cache_ranges_held: RwLock<Vec<RangeInclusive<Pubkey>>>,
    /* private fields */
}

Fields

cache_ranges_held: RwLock<Vec<RangeInclusive<Pubkey>>>

Implementations

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

pub fn new(storage: &Arc<BucketMapHolder<T, U>>, bin: usize) -> Self

pub fn shrink_to_fit(&self)

Release entire in-mem hashmap to free all memory associated with it. Idea is that during startup we needed a larger map than we need during runtime. When using disk-buckets, in-mem index grows over time with dynamic use and then shrinks, in theory back to 0.

pub fn items<R>(&self, range: &R) -> Vec<(Pubkey, Arc<AccountMapEntryInner<T>>)>

where R: RangeBounds<Pubkey> + Debug,

pub fn keys(&self) -> Vec<Pubkey>

pub fn get(&self, pubkey: &Pubkey) -> Option<Arc<AccountMapEntryInner<T>>>

lookup ‘pubkey’ in index (in mem or on disk)

pub fn get_internal<RT>( &self, pubkey: &Pubkey, callback: impl for<'a> FnOnce(Option<&Arc<AccountMapEntryInner<T>>>) -> (bool, RT), ) -> RT

lookup ‘pubkey’ in index (in_mem or disk). call ‘callback’ whether found or not

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

pub fn slot_list_mut<RT>( &self, pubkey: &Pubkey, user: impl for<'a> FnOnce(&mut RwLockWriteGuard<'a, SlotList<T>>) -> RT, ) -> Option<RT>

pub fn upsert( &self, pubkey: &Pubkey, new_value: PreAllocatedAccountMapEntry<T>, other_slot: Option<Slot>, reclaims: &mut SlotList<T>, reclaim: UpsertReclaim, )

pub fn lock_and_update_slot_list( current: &AccountMapEntryInner<T>, new_value: (Slot, T), other_slot: Option<Slot>, reclaims: &mut SlotList<T>, reclaim: UpsertReclaim, ) -> usize

Try to update an item in the slot list the given slot If an item for the slot already exists in the list, remove the older item, add it to reclaims, and insert the new item. if ‘other_slot’ is some, then also remove any entries in the slot list that are at ‘other_slot’ return resulting len of slot list

pub fn len_for_stats(&self) -> usize

pub fn startup_insert_only( &self, items: impl Iterator<Item = (Pubkey, (Slot, T))>, )

Queue up these insertions for when the flush thread is dealing with this bin. This is very fast and requires no lookups or disk access.

pub fn insert_new_entry_if_missing_with_lock( &self, pubkey: Pubkey, new_entry: PreAllocatedAccountMapEntry<T>, ) -> InsertNewEntryResults

pub fn hold_range_in_memory<R>(&self, range: &R, start_holding: bool)

where R: RangeBounds<Pubkey> + Debug,

if ‘start_holding’=true, then: at the end of this function, cache_ranges_held will be updated to contain ‘range’ and all pubkeys in that range will be in the in-mem cache if ‘start_holding’=false, then: ‘range’ will be removed from cache_ranges_held and all pubkeys will be eligible for being removed from in-mem cache in the bg if no other range is holding them Any in-process flush will be aborted when it gets to evicting items from in-mem.

pub fn flush(&self, can_advance_age: bool)

pub fn populate_and_retrieve_duplicate_keys_from_startup( &self, ) -> Vec<(Slot, Pubkey)>

pull out all duplicate pubkeys from ‘startup_info’ duplicate pubkeys have a slot list with len > 1 These were collected for this bin when we did batch inserts in the bg flush threads. Insert these into the in-mem index, then return the duplicate (Slot, Pubkey)

pub fn stats(&self) -> &BucketMapHolderStats

pub fn update_time_stat(stat: &AtomicU64, m: Measure)

Trait Implementations

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

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

Formats the value using the given formatter.