Struct TelemetryAccumulator 

pub struct TelemetryAccumulator {

    pub(crate) iteration_count: u32,
    pub(crate) dps_sum: f64,
    pub(crate) dps_min: f64,
    pub(crate) dps_max: f64,
    pub(crate) spell_totals: FastMap<ActionAggregateKey, SpellAggregate>,
    pub(crate) dps_welford_mean: f64,
    pub(crate) dps_m2: f64,
    pub(crate) dps_histogram: Histogram<u64>,
    pub(crate) representative_dps: Option<f64>,
    pub(crate) representative_candidates: Vec<RepresentativeIteration>,
    pub(crate) aura_totals: FastMap<AuraAggregateKey, AuraAggregate>,
    pub(crate) resource_totals: IntMap<u8, ResourceAggregate>,
    pub(crate) cooldown_totals: IntMap<u32, CooldownAggregate>,
    pub(crate) total_duration_ms: f64,
    pub(crate) gcd_locked_ms_total: f64,
    pub(crate) representative_sink: Option<RepresentativeTimeline>,
    pub(crate) direct_damage_total: f64,
    pub(crate) periodic_damage_total: f64,
    pub(crate) pet_damage_total: f64,
    pub(crate) damage_by_target: FastMap<EnemyIdx, f64>,
    pub(crate) targets: FastMap<TargetIdx, TargetMetadata>,
    pub(crate) bucket_sums: Vec<f64>,
    pub(crate) bucket_samples: Vec<u64>,
    pub(crate) trace_extras_enabled: bool,
}

Accumulates telemetry incrementally across all iterations.

Fields

iteration_count: u32

dps_sum: f64

dps_min: f64

dps_max: f64

spell_totals: FastMap<ActionAggregateKey, SpellAggregate>

dps_welford_mean: f64

dps_m2: f64

dps_histogram: Histogram<u64>

representative_dps: Option<f64>

representative_candidates: Vec<RepresentativeIteration>

aura_totals: FastMap<AuraAggregateKey, AuraAggregate>

resource_totals: IntMap<u8, ResourceAggregate>

cooldown_totals: IntMap<u32, CooldownAggregate>

total_duration_ms: f64

gcd_locked_ms_total: f64

representative_sink: Option<RepresentativeTimeline>

direct_damage_total: f64

periodic_damage_total: f64

pet_damage_total: f64

damage_by_target: FastMap<EnemyIdx, f64>

targets: FastMap<TargetIdx, TargetMetadata>

bucket_sums: Vec<f64>

bucket_samples: Vec<u64>

Per-bucket sample count: divide each bucket_sums entry by this, not by total iterations.

trace_extras_enabled: bool

Implementations

impl TelemetryAccumulator

pub fn encode(self, chunk_index: u32, permutation_index: Option<u64>) -> Vec<u8>

Encode accumulated telemetry as protobuf bytes.

impl TelemetryAccumulator

pub fn merge(&mut self, other: Self)

Merge another accumulator into this one (for parallel execution).

impl TelemetryAccumulator

pub(crate) fn capture_representative( &mut self, sink: &TelemetrySink, duration_ms: u32, )

impl TelemetryAccumulator

pub fn new() -> Self

Empty accumulator.

pub fn enable_trace_extras(&mut self)

Enable resource-sample + aura-interval collection.

pub fn running_stats(&self) -> Option<RunningDpsStats>

Running DPS snapshot; None before any iterations.

pub fn record_iteration(&mut self, dps: f64)

Record one completed iteration without externally supplied RNG identity.

pub fn representative_iteration(&self) -> Option<RepresentativeIteration>

Return the completed iteration nearest the final aggregate mean, tie-broken by (seed_prefix, iteration) for determinism.

pub const fn representative_dps(&self) -> Option<f64>

DPS of the installed exact representative, or None until its capture-only rerun completes.

pub(crate) fn record_sink_events( &mut self, sink: &TelemetrySink, duration_secs: f64, )

Aggregate sink events into cross-iteration totals.

pub(crate) fn record_iteration_for( &mut self, seed_prefix: u64, iteration: u32, dps: f64, )

pub(crate) fn install_representative( &mut self, dps: f64, sink: &TelemetrySink, duration_secs: f64, )

fn record_damage_events(&mut self, sink: &TelemetrySink, duration_ms: u32)

fn record_aura_events(&mut self, sink: &TelemetrySink, duration_ms: u32)

fn record_resource_events(&mut self, sink: &TelemetrySink)

fn record_action_events(&mut self, sink: &TelemetrySink)

Trait Implementations

impl Debug for TelemetryAccumulator

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

Formats the value using the given formatter.

impl Default for TelemetryAccumulator

fn default() -> Self

Returns the “default value” for a type.