Struct TransferStageProfile 

pub struct TransferStageProfile {
    pub calls: u64,
    pub transfers: u64,
    pub validation: Duration,
    pub setup: Duration,
    pub submit: Duration,
    pub wait_write: Duration,
    pub wait_read: Duration,
    pub decode_copy: Duration,
}

Fields

calls: u64

transfers: u64

validation: Duration

setup: Duration

submit: Duration

wait_write: Duration

wait_read: Duration

decode_copy: Duration

Implementations

impl TransferStageProfile

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

Examples found in repository

examples/bench_transfer.rs (line 170)

fn run_device_bench(options: &Options) -> Result<(), Box<dyn Error>> {
    let mut board = Board::open_with_transport(options.transport)?;
    let max_cycles_per_transfer = usize::from(board.config().fifo_size_words()) / WORDS_PER_CYCLE;
    let mut io = board.configure_io(&IoConfig {
        clock_high_delay: options.clock_high_delay,
        clock_low_delay: options.clock_low_delay,
        ..IoConfig::default()
    })?;

    if options.window == 0 {
        return Err("window must be at least 1".into());
    }

    let template = vec![0x1234u16; options.words];
    let mut rx = vec![0u16; options.words];
    let mut outputs = vec![vec![0u16; options.words]; options.window];
    let mut stage_profile = TransferStageProfile::default();

    let started = Instant::now();
    if options.window == 1 {
        if options.profile_stages {
            for _ in 0..options.iterations {
                let profile = io.transfer_profiled_into(&template, &mut rx)?;
                stage_profile.merge(&profile);
            }
        } else {
            for _ in 0..options.iterations {
                io.transfer(&template, &mut rx)?;
            }
        }
    } else {
        let mut window = io.transfer_window(options.words, options.window)?;
        let initial = options.iterations.min(options.window);
        for _ in 0..initial {
            if options.profile_stages {
                let profile = window.submit_profiled(&template)?;
                stage_profile.merge(&profile);
            } else {
                window.submit(&template)?;
            }
        }

        let mut submitted = initial;
        let mut completed = 0usize;
        while completed < options.iterations {
            let output = outputs[completed % options.window].as_mut_slice();
            if options.profile_stages {
                let profile = window.receive_into_profiled(output)?;
                stage_profile.merge(&profile);
            } else {
                window.receive_into(output)?;
            }
            completed += 1;

            if submitted < options.iterations {
                if options.profile_stages {
                    let profile = window.submit_profiled(&template)?;
                    stage_profile.merge(&profile);
                } else {
                    window.submit(&template)?;
                }
                submitted += 1;
            }
        }
    }
    let elapsed = started.elapsed();
    io.finish()?;

    print_summary(
        "device",
        options.words,
        options.iterations,
        elapsed,
        Some(max_cycles_per_transfer),
    );
    if options.profile_stages {
        print_stage_profile(&stage_profile, elapsed);
    }
    Ok(())
}

pub fn total_duration(&self) -> Duration

Examples found in repository

examples/bench_transfer.rs (line 258)

fn print_stage_profile(profile: &TransferStageProfile, elapsed: Duration) {
    let accounted = profile.total_duration();
    let elapsed_secs = elapsed.as_secs_f64().max(f64::MIN_POSITIVE);
    let accounted_secs = accounted.as_secs_f64().max(f64::MIN_POSITIVE);
    let transfers = profile.transfers.max(1);

    println!(
        "profile calls={} transfers={} accounted={:?} wall={:?} unaccounted={:?}",
        profile.calls,
        profile.transfers,
        accounted,
        elapsed,
        elapsed.saturating_sub(accounted),
    );

    for (stage, duration) in [
        ("validation", profile.validation),
        ("setup", profile.setup),
        ("submit", profile.submit),
        ("wait_write", profile.wait_write),
        ("wait_read", profile.wait_read),
        ("decode_copy", profile.decode_copy),
    ] {
        let pct_of_accounted = duration.as_secs_f64() * 100.0 / accounted_secs;
        let pct_of_wall = duration.as_secs_f64() * 100.0 / elapsed_secs;
        let avg_us_per_transfer = duration.as_secs_f64() * 1_000_000.0 / transfers as f64;
        println!(
            "stage={stage} duration={duration:?} pct_accounted={pct_of_accounted:.2} pct_wall={pct_of_wall:.2} avg_us_per_transfer={avg_us_per_transfer:.3}"
        );
    }
}

Trait Implementations

impl Clone for TransferStageProfile

fn clone(&self) -> TransferStageProfile

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for TransferStageProfile

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

Formats the value using the given formatter.

impl Default for TransferStageProfile

fn default() -> TransferStageProfile

Returns the “default value” for a type.

impl PartialEq for TransferStageProfile

fn eq(&self, other: &TransferStageProfile) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for TransferStageProfile

impl StructuralPartialEq for TransferStageProfile