Struct webrender::lru_cache::LRUTracker

struct LRUTracker<H> {
    head: Option<ItemIndex>,
    tail: Option<ItemIndex>,
    free_list_head: Option<ItemIndex>,
    items: Vec<Item<H>>,
}

Internal implementation of the LRU tracking list

Fields

head: Option<ItemIndex>

Current head of the list - this is the oldest item that will be evicted next.

tail: Option<ItemIndex>

Current tail of the list - this is the most recently used element.

free_list_head: Option<ItemIndex>

As tracking items are removed, they are stored in a freelist, to minimize heap allocations

items: Vec<Item<H>>

The freelist that stores all the LRU tracking items

Implementations

impl<H> LRUTracker<H>

where H: Debug,

fn new() -> Self

Construct a new LRU tracker

fn link_as_new_tail(&mut self, item_index: ItemIndex)

Internal function that takes an item index, and links it to the end of the tracker list (makes it the newest item).

fn unlink(&mut self, item_index: ItemIndex)

Internal function that takes an LRU item index, and removes it from the current doubly linked list. Used during removal of items, and also when items are moved to the back of the list as they’re touched.

fn push_new(&mut self, handle: H) -> ItemIndex

Push a new LRU tracking item on to the back of the list, marking it as the most recent item.

fn peek_front(&self) -> Option<&H>

Returns a reference to the oldest element, or None if the list is empty.

fn pop_front(&mut self) -> Option<H>

Remove the oldest element from the front of the LRU list. Returns None if the list is empty.

fn remove(&mut self, index: ItemIndex) -> H

Manually remove an item from the LRU tracking list. This is used when an element switches from one LRU partition to a different one.

fn mark_used(&mut self, index: ItemIndex)

Called to mark that an item was used on this frame. It unlinks the tracking item, and then re-links it to the back of the list.

Trait Implementations

impl<H> MallocSizeOf for LRUTracker<H>

where H: MallocSizeOf,

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl<H> Serialize for LRUTracker<H>

where H: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.