pub struct MemoryTrace {
    pub id: Id,
    trace: AtomicUsize,
    children: HashMap<Id, Arc<MemoryTrace>>,
}

pub static ref MEMTRACE_ROOT: Arc<MemoryTrace> = mem_trace!(
    raftstore,
    [
        peers,
        applys,
        entry_cache,
        // ...
        raft_messages,
        raft_entries
    ])

/// Memory usage for raft peers fsms.
pub static ref MEMTRACE_PEERS: Arc<MemoryTrace> =
    MEMTRACE_ROOT.sub_trace(Id::Name("peers"));
/// ...

/// Heap size trace for received Raft Messages.
pub static ref MEMTRACE_RAFT_MESSAGES: Arc<MemoryTrace> =
    MEMTRACE_ROOT.sub_trace(Id::Name("raft_messages"));
/// ...

impl<EK, ER> RaftRouter<EK, ER>
where
    EK: KvEngine,
    ER: RaftEngine,
{
    pub fn send_raft_message(
        &self,
        msg: RaftMessage,
    ) -> std::result::Result<(), TrySendError<RaftMessage>>
        // ...
        let mut heap_size = 0;
        for e in msg.get_message().get_entries() {
            heap_size += bytes_capacity(&e.data) + bytes_capacity(&e.context);
        }
        let event = TraceEvent::Add(heap_size);
        // ...
        MEMTRACE_RAFT_MESSAGES.trace(event);
        defer!(if send_failed.get() {
            MEMTRACE_RAFT_MESSAGES.trace(TraceEvent::Sub(heap_size));
        });
        // ...
    }
}

impl<'a, EK, ER, T: Transport> PeerFsmDelegate<'a, EK, ER, T>
where
    EK: KvEngine,
    ER: RaftEngine,
{
    fn on_raft_message(&mut self, m: Box<InspectedRaftMessage>) -> Result<()> {
        // ...
        defer!({
            // ...
            MEMTRACE_RAFT_MESSAGES.trace(TraceEvent::Sub(heap_size));
            if stepped.get() {
                unsafe {
                    // It could be less than exact for entry overwriting.
                    *memtrace_raft_Entries += heap_size;
                    MEMTRACE_RAFT_Entries.trace(TraceEvent::Add(heap_size));
                }
            }
        });
        // ...
}

self.core.background_worker.spawn_interval_task(
    DEFAULT_MEMTRACE_FLUSH_INTERVAL,
    move || {
        let now = Instant::now();
        mem_trace_metrics.flush(now);
    },
);

impl<T: Storage> RaftLog<T> {
    /// ...
    /// Grabs a slice of entries from the raft. Unlike a rust slice pointer, these are
    /// returned by value. The result is truncated to the max_size in bytes.
    pub fn slice(
        &self,
        low: u64,
        high: u64,
        max_size: impl Into<Option<u64>>,
        context: GetEntriesContext,
    ) -> Result<Vec<Entry>> {
        // ...
        if low < self.unstable.offset {
            // ...
            match self.store.entries(low, unstable_high, max_size, context)
        }
        // ...
    }
    // ...
}

pub fn compact_to(&mut self, mut idx: u64) -> u64 {
    if idx > self.persisted + 1 {
        // Only the persisted entries can be compacted
        idx = self.persisted + 1;
    }
    // ...
    while let Some(cached_entries) = self.trace.pop_front() {
        // Do not evict cached entries if not all of them are persisted.
        // After PR #16626, it is possible that applying entries are not
        // yet fully persisted. Therefore, it should not free these
        // entries until they are completely persisted.
        if cached_entries.range.start >= idx || cached_entries.range.end > self.persisted + 1 {
            self.trace.push_front(cached_entries);
            let trace_len = self.trace.len();
            let trace_cap = self.trace.capacity();
            if trace_len < SHRINK_CACHE_CAPACITY && trace_cap > SHRINK_CACHE_CAPACITY {
                self.trace.shrink_to(SHRINK_CACHE_CAPACITY);
            }
            break;
        }
        let (_, dangle_size) = cached_entries.take_entries();
        // ...
        idx = cmp::max(cached_entries.range.end, idx);
    }
    // ...

    let cache_first_idx = self.first_index().unwrap_or(u64::MAX);
    // ...

    let cache_last_idx = self.cache.back().unwrap().get_index();
    // Use `cache_last_idx + 1` to make sure cache can be cleared completely if
    // necessary.
    let compact_to = (cmp::min(cache_last_idx + 1, idx) - cache_first_idx) as usize;
    for e in self.cache.drain(..compact_to) {
        // ...
    }
    // ...
}