Struct ThreadLocalCounters 

pub struct ThreadLocalCounters { /* private fields */ }

Thread-local counter buffer (Kaizen: eliminates atomic contention)

Instead of atomic increments on every block hit, counters are buffered locally and flushed periodically. This dramatically reduces cache coherence traffic in parallel coverage collection.

Implementations

impl ThreadLocalCounters

pub fn new(block_count: usize) -> Self

Create new thread-local counters for the given number of blocks

Uses a default flush threshold of 1000 blocks.

pub fn with_flush_threshold(block_count: usize, threshold: usize) -> Self

Create with a custom flush threshold

Lower thresholds mean more frequent flushes (more accurate but slower). Higher thresholds mean fewer flushes (faster but less accurate intermediate state).

pub fn increment(&mut self, block: BlockId)

Increment counter locally (no atomic, no cache coherence traffic)

This is the hot path - must be as fast as possible.

pub fn get(&self, block: BlockId) -> u64

Get the current local count for a block (before flush)

pub fn flush(&mut self) -> Vec<u64>

Flush local counters and return the counts

Returns the accumulated counts and resets the local buffer.

pub fn flush_count(&self) -> usize

Get the number of times flush has been called

pub fn block_count(&self) -> usize

Get the number of blocks being tracked

pub fn has_pending(&self) -> bool

Check if any blocks have been hit since last flush

pub fn flush_threshold(&self) -> usize

Get the flush threshold

Trait Implementations

impl Debug for ThreadLocalCounters

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

Formats the value using the given formatter.

impl Default for ThreadLocalCounters

fn default() -> Self

Returns the “default value” for a type.