Struct BrickStats 

pub struct BrickStats {
    pub name: String,
    pub count: u64,
    pub total_ns: u64,
    pub min_ns: u64,
    pub max_ns: u64,
    pub total_elements: u64,
    pub total_bytes: u64,
    pub total_compressed_bytes: u64,
    pub bottleneck: BrickBottleneck,
    pub total_cycles: u64,
    pub min_cycles: u64,
    pub max_cycles: u64,
}

Accumulated per-brick statistics.

Fields

name: String

Brick name

count: u64

Total samples collected

total_ns: u64

Total elapsed time (nanoseconds)

min_ns: u64

Min elapsed time (nanoseconds)

max_ns: u64

Max elapsed time (nanoseconds)

total_elements: u64

Total elements processed

total_bytes: u64

PMAT-451: Total bytes processed (for throughput calculation)

total_compressed_bytes: u64

PMAT-451: Total compressed bytes (for compression ratio)

bottleneck: BrickBottleneck

PMAT-451: Bottleneck classification

total_cycles: u64

Phase 11 (E.9.2): Total CPU cycles (from RDTSCP/CNTVCT)

min_cycles: u64

Phase 11: Minimum CPU cycles observed

max_cycles: u64

Phase 11: Maximum CPU cycles observed

Implementations

impl BrickStats

pub fn new(name: &str) -> Self

Create new stats for a brick.

pub fn add_sample(&mut self, elapsed_ns: u64, elements: u64)

Add a sample to statistics.

pub fn add_sample_with_cycles( &mut self, elapsed_ns: u64, elements: u64, cycles: u64, )

Phase 11 (E.9.2): Add a sample with CPU cycle count.

Use this for frequency-invariant performance analysis. Cycles are immune to CPU frequency scaling (turbo boost).

pub fn cycles_per_element(&self) -> f64

Phase 11: Cycles per element (frequency-invariant throughput metric).

Lower is better. This metric is immune to CPU frequency scaling.

pub fn avg_cycles(&self) -> f64

Phase 11: Average cycles per sample.

pub fn estimated_ipc(&self) -> f64

Phase 11: Estimated IPC (Instructions Per Cycle).

Approximation assuming ~1 instruction per element for simple ops.

• Low IPC (<1.0): Memory stalls (cache misses, memory latency)
• High IPC (>2.0): Compute bound (efficient execution)

pub fn diagnose_from_cycles(&self) -> &'static str

Phase 11: Diagnose bottleneck based on cycles vs time ratio.

High cycles + low time = likely cache misses Low cycles + high time = likely CPU throttling or context switches

pub fn add_sample_with_bytes( &mut self, elapsed_ns: u64, elements: u64, input_bytes: u64, output_bytes: u64, )

PMAT-451: Add a sample with byte metrics for compression workloads.

Arguments

• elapsed_ns: Time taken in nanoseconds
• elements: Number of elements processed (e.g., pages)
• input_bytes: Original uncompressed size
• output_bytes: Compressed output size

pub fn compression_ratio(&self) -> f64

PMAT-451: Calculate compression ratio (input_size / output_size). Returns 1.0 if no compression data available.

pub fn throughput_gbps(&self) -> f64

PMAT-451: Calculate throughput in GB/s. Based on total input bytes processed.

pub fn set_bottleneck(&mut self, bottleneck: BrickBottleneck)

PMAT-451: Set bottleneck classification.

pub fn get_bottleneck(&self) -> BrickBottleneck

PMAT-451: Get bottleneck classification.

pub fn avg_us(&self) -> f64

Average time in microseconds.

pub fn throughput(&self) -> f64

Throughput in elements/second.

pub fn tokens_per_sec(&self) -> f64

Throughput in tokens/second (alias for throughput).

pub fn min_us(&self) -> f64

Minimum time in microseconds.

pub fn max_us(&self) -> f64

Maximum time in microseconds.

Trait Implementations

impl Clone for BrickStats

fn clone(&self) -> BrickStats

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BrickStats

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

Formats the value using the given formatter.

impl Default for BrickStats

fn default() -> BrickStats

Returns the “default value” for a type.